diff --git a/extensions/openpower-pels/entry_points.cpp b/extensions/openpower-pels/entry_points.cpp
index 156c666..c904afb 100644
--- a/extensions/openpower-pels/entry_points.cpp
+++ b/extensions/openpower-pels/entry_points.cpp
@@ -17,6 +17,7 @@
 #include "elog_entry.hpp"
 #include "event_logger.hpp"
 #include "extensions.hpp"
+#include "journal.hpp"
 #include "manager.hpp"
 #include "pldm_interface.hpp"
 
@@ -44,16 +45,18 @@
     std::unique_ptr<DataInterfaceBase> dataIface =
         std::make_unique<DataInterface>(logManager.getBus());
 
+    std::unique_ptr<JournalBase> journal = std::make_unique<Journal>();
+
 #ifndef DONT_SEND_PELS_TO_HOST
     std::unique_ptr<HostInterface> hostIface = std::make_unique<PLDMInterface>(
         logManager.getBus().get_event(), *(dataIface.get()));
 
     manager = std::make_unique<Manager>(logManager, std::move(dataIface),
-                                        std::move(logger),
+                                        std::move(logger), std::move(journal),
                                         std::move(hostIface));
 #else
     manager = std::make_unique<Manager>(logManager, std::move(dataIface),
-                                        std::move(logger));
+                                        std::move(logger), std::move(journal));
 #endif
 
 #ifdef PEL_ENABLE_PHAL
diff --git a/extensions/openpower-pels/journal.cpp b/extensions/openpower-pels/journal.cpp
new file mode 100644
index 0000000..0a728f0
--- /dev/null
+++ b/extensions/openpower-pels/journal.cpp
@@ -0,0 +1,176 @@
+/**
+ * Copyright © 2023 IBM Corporation
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#include "journal.hpp"
+
+#include <phosphor-logging/log.hpp>
+
+#include <stdexcept>
+#include <thread>
+
+namespace openpower::pels
+{
+
+using namespace phosphor::logging;
+
+/**
+ * @class JournalCloser
+ *
+ * Closes the journal on destruction
+ */
+class JournalCloser
+{
+  public:
+    JournalCloser() = delete;
+    JournalCloser(const JournalCloser&) = delete;
+    JournalCloser(JournalCloser&&) = delete;
+    JournalCloser& operator=(const JournalCloser&) = delete;
+    JournalCloser& operator=(JournalCloser&&) = delete;
+
+    explicit JournalCloser(sd_journal* journal) : journal{journal} {}
+
+    ~JournalCloser()
+    {
+        sd_journal_close(journal);
+    }
+
+  private:
+    sd_journal* journal{nullptr};
+};
+
+std::vector<std::string> Journal::getMessages(const std::string& syslogID,
+                                              size_t maxMessages) const
+{
+    // The message registry JSON schema will also fail if a zero is in the JSON
+    if (0 == maxMessages)
+    {
+        log<level::ERR>(
+            "maxMessages value of zero passed into Journal::getMessages");
+        return std::vector<std::string>{};
+    }
+
+    sd_journal* journal;
+    int rc = sd_journal_open(&journal, SD_JOURNAL_LOCAL_ONLY);
+    if (rc < 0)
+    {
+        throw std::runtime_error{std::string{"Failed to open journal: "} +
+                                 strerror(-rc)};
+    }
+
+    JournalCloser closer{journal};
+
+    if (!syslogID.empty())
+    {
+        std::string match{"SYSLOG_IDENTIFIER=" + syslogID};
+
+        rc = sd_journal_add_match(journal, match.c_str(), 0);
+        if (rc < 0)
+        {
+            throw std::runtime_error{
+                std::string{"Failed to add journal match: "} + strerror(-rc)};
+        }
+    }
+
+    // Loop through matching entries from newest to oldest
+    std::vector<std::string> messages;
+    messages.reserve(maxMessages);
+    std::string sID, pid, message, timeStamp, line;
+
+    SD_JOURNAL_FOREACH_BACKWARDS(journal)
+    {
+        timeStamp = getTimeStamp(journal);
+        sID = getFieldValue(journal, "SYSLOG_IDENTIFIER");
+        pid = getFieldValue(journal, "_PID");
+        message = getFieldValue(journal, "MESSAGE");
+
+        line = timeStamp + " " + sID + "[" + pid + "]: " + message;
+        messages.emplace(messages.begin(), line);
+
+        if (messages.size() >= maxMessages)
+        {
+            break;
+        }
+    }
+
+    return messages;
+}
+
+std::string Journal::getFieldValue(sd_journal* journal,
+                                   const std::string& field) const
+{
+    std::string value{};
+
+    const void* data{nullptr};
+    size_t length{0};
+    int rc = sd_journal_get_data(journal, field.c_str(), &data, &length);
+    if (rc < 0)
+    {
+        if (-rc == ENOENT)
+        {
+            // Current entry does not include this field; return empty value
+            return value;
+        }
+        else
+        {
+            throw std::runtime_error{
+                std::string{"Failed to read journal entry field: "} +
+                strerror(-rc)};
+        }
+    }
+
+    // Get value from field data.  Field data in format "FIELD=value".
+    std::string dataString{static_cast<const char*>(data), length};
+    std::string::size_type pos = dataString.find('=');
+    if ((pos != std::string::npos) && ((pos + 1) < dataString.size()))
+    {
+        // Value is substring after the '='
+        value = dataString.substr(pos + 1);
+    }
+
+    return value;
+}
+
+std::string Journal::getTimeStamp(sd_journal* journal) const
+{
+    // Get realtime (wallclock) timestamp of current journal entry.  The
+    // timestamp is in microseconds since the epoch.
+    uint64_t usec{0};
+    int rc = sd_journal_get_realtime_usec(journal, &usec);
+    if (rc < 0)
+    {
+        throw std::runtime_error{
+            std::string{"Failed to get journal entry timestamp: "} +
+            strerror(-rc)};
+    }
+
+    // Convert to number of seconds since the epoch
+    time_t secs = usec / 1000000;
+
+    // Convert seconds to tm struct required by strftime()
+    struct tm* timeStruct = localtime(&secs);
+    if (timeStruct == nullptr)
+    {
+        throw std::runtime_error{
+            std::string{"Invalid journal entry timestamp: "} + strerror(errno)};
+    }
+
+    // Convert tm struct into a date/time string
+    char timeStamp[80];
+    strftime(timeStamp, sizeof(timeStamp), "%b %d %H:%M:%S", timeStruct);
+
+    return timeStamp;
+}
+
+} // namespace openpower::pels
diff --git a/extensions/openpower-pels/journal.hpp b/extensions/openpower-pels/journal.hpp
new file mode 100644
index 0000000..1261e32
--- /dev/null
+++ b/extensions/openpower-pels/journal.hpp
@@ -0,0 +1,84 @@
+#pragma once
+
+#include <systemd/sd-journal.h>
+
+#include <string>
+#include <vector>
+
+namespace openpower::pels
+{
+
+/**
+ * @class JournalBase
+ * Abstract class to read messages from the journal.
+ */
+class JournalBase
+{
+  public:
+    JournalBase() = default;
+    virtual ~JournalBase() = default;
+    JournalBase(const JournalBase&) = default;
+    JournalBase& operator=(const JournalBase&) = default;
+    JournalBase(JournalBase&&) = default;
+    JournalBase& operator=(JournalBase&&) = default;
+
+    /**
+     * @brief Get messages from the journal
+     *
+     * @param syslogID - The SYSLOG_IDENTIFIER field value
+     * @param maxMessages - Max number of messages to get
+     *
+     * @return The messages
+     */
+    virtual std::vector<std::string> getMessages(const std::string& syslogID,
+                                                 size_t maxMessages) const = 0;
+};
+
+/**
+ * @class Journal
+ *
+ * Reads from the journal.
+ */
+class Journal : public JournalBase
+{
+  public:
+    Journal() = default;
+    ~Journal() = default;
+    Journal(const Journal&) = default;
+    Journal& operator=(const Journal&) = default;
+    Journal(Journal&&) = default;
+    Journal& operator=(Journal&&) = default;
+
+    /**
+     * @brief Get messages from the journal
+     *
+     * @param syslogID - The SYSLOG_IDENTIFIER field value
+     * @param maxMessages - Max number of messages to get
+     *
+     * @return The messages
+     */
+    std::vector<std::string> getMessages(const std::string& syslogID,
+                                         size_t maxMessages) const override;
+
+  private:
+    /**
+     * @brief Gets a field from the current journal entry
+     *
+     * @param journal - pointer to current journal entry
+     * @param field - The field name whose value to get
+     *
+     * @return std::string - The field value
+     */
+    std::string getFieldValue(sd_journal* journal,
+                              const std::string& field) const;
+
+    /**
+     * @brief Gets a readable timestamp from the journal entry
+     *
+     * @param journal - pointer to current journal entry
+     *
+     * @return std::string - A timestamp string
+     */
+    std::string getTimeStamp(sd_journal* journal) const;
+};
+} // namespace openpower::pels
diff --git a/extensions/openpower-pels/manager.hpp b/extensions/openpower-pels/manager.hpp
index 44a9ec2..8f439a5 100644
--- a/extensions/openpower-pels/manager.hpp
+++ b/extensions/openpower-pels/manager.hpp
@@ -5,6 +5,7 @@
 #include "data_interface.hpp"
 #include "event_logger.hpp"
 #include "host_notifier.hpp"
+#include "journal.hpp"
 #include "log_manager.hpp"
 #include "paths.hpp"
 #include "pel.hpp"
@@ -48,13 +49,14 @@
      */
     Manager(phosphor::logging::internal::Manager& logManager,
             std::unique_ptr<DataInterfaceBase> dataIface,
-            EventLogger::LogFunction creatorFunc) :
+            EventLogger::LogFunction creatorFunc,
+            std::unique_ptr<JournalBase> journal) :
         PELInterface(logManager.getBus(), OBJ_LOGGING),
         _logManager(logManager), _eventLogger(std::move(creatorFunc)),
         _repo(getPELRepoPath()),
         _registry(getPELReadOnlyDataPath() / message::registryFileName),
         _event(sdeventplus::Event::get_default()),
-        _dataIface(std::move(dataIface))
+        _dataIface(std::move(dataIface)), _journal(std::move(journal))
     {
         for (const auto& entry : _logManager.entries)
         {
@@ -82,8 +84,10 @@
     Manager(phosphor::logging::internal::Manager& logManager,
             std::unique_ptr<DataInterfaceBase> dataIface,
             EventLogger::LogFunction creatorFunc,
+            std::unique_ptr<JournalBase> journal,
             std::unique_ptr<HostInterface> hostIface) :
-        Manager(logManager, std::move(dataIface), std::move(creatorFunc))
+        Manager(logManager, std::move(dataIface), std::move(creatorFunc),
+                std::move(journal))
     {
         _hostNotifier = std::make_unique<HostNotifier>(
             _repo, *(_dataIface.get()), std::move(hostIface));
@@ -506,6 +510,11 @@
     std::unique_ptr<DataInterfaceBase> _dataIface;
 
     /**
+     * @brief Object used to read from the journal
+     */
+    std::unique_ptr<JournalBase> _journal;
+
+    /**
      * @brief The map used to keep track of PEL entry pointer associated with
      *        event log.
      */
diff --git a/extensions/openpower-pels/meson.build b/extensions/openpower-pels/meson.build
index a29d257..6a07322 100644
--- a/extensions/openpower-pels/meson.build
+++ b/extensions/openpower-pels/meson.build
@@ -62,6 +62,7 @@
     'failing_mtms.cpp',
     'fru_identity.cpp',
     'generic.cpp',
+    'journal.cpp',
     'json_utils.cpp',
     'log_id.cpp',
     'mru.cpp',