diff --git a/extensions/openpower-pels/manager.cpp b/extensions/openpower-pels/manager.cpp
index a009188..ef071bd 100644
--- a/extensions/openpower-pels/manager.cpp
+++ b/extensions/openpower-pels/manager.cpp
@@ -94,6 +94,9 @@
 
 void Manager::erase(uint32_t obmcLogID)
 {
+    Repository::LogID id{Repository::LogID::Obmc(obmcLogID)};
+
+    _repo.remove(id);
 }
 
 bool Manager::isDeleteProhibited(uint32_t obmcLogID)
diff --git a/extensions/openpower-pels/repository.cpp b/extensions/openpower-pels/repository.cpp
index c9f9521..aa6a18b 100644
--- a/extensions/openpower-pels/repository.cpp
+++ b/extensions/openpower-pels/repository.cpp
@@ -20,6 +20,50 @@
     {
         fs::create_directories(_logPath);
     }
+
+    restore();
+}
+
+void Repository::restore()
+{
+    for (auto& dirEntry : fs::directory_iterator(_logPath))
+    {
+        try
+        {
+            if (!fs::is_regular_file(dirEntry.path()))
+            {
+                continue;
+            }
+
+            std::ifstream file{dirEntry.path()};
+            std::vector<uint8_t> data{std::istreambuf_iterator<char>(file),
+                                      std::istreambuf_iterator<char>()};
+            file.close();
+
+            PEL pel(std::move(data));
+            if (pel.valid())
+            {
+                using pelID = LogID::Pel;
+                using obmcID = LogID::Obmc;
+                _idsToPELs.emplace(
+                    LogID(pelID(pel.id()), obmcID(pel.obmcLogID())),
+                    dirEntry.path());
+            }
+            else
+            {
+                log<level::ERR>(
+                    "Found invalid PEL file while restoring.  Removing.",
+                    entry("FILENAME=%s", dirEntry.path().c_str()));
+                fs::remove(dirEntry.path());
+            }
+        }
+        catch (std::exception& e)
+        {
+            log<level::ERR>("Hit exception while restoring PEL File",
+                            entry("FILENAME=%s", dirEntry.path().c_str()),
+                            entry("ERROR=%s", e.what()));
+        }
+    }
 }
 
 std::string Repository::getPELFilename(uint32_t pelID, const BCDTime& time)
@@ -65,6 +109,20 @@
                         entry("PATH=%s", path.c_str()));
         throw file_error::Write();
     }
+
+    using pelID = LogID::Pel;
+    using obmcID = LogID::Obmc;
+    _idsToPELs.emplace(LogID(pelID(pel->id()), obmcID(pel->obmcLogID())), path);
+}
+
+void Repository::remove(const LogID& id)
+{
+    auto pel = findPEL(id);
+    if (pel != _idsToPELs.end())
+    {
+        fs::remove(pel->second);
+        _idsToPELs.erase(pel);
+    }
 }
 
 } // namespace pels
diff --git a/extensions/openpower-pels/repository.hpp b/extensions/openpower-pels/repository.hpp
index 5b15506..289541c 100644
--- a/extensions/openpower-pels/repository.hpp
+++ b/extensions/openpower-pels/repository.hpp
@@ -4,6 +4,7 @@
 
 #include <algorithm>
 #include <filesystem>
+#include <map>
 
 namespace openpower
 {
@@ -18,6 +19,72 @@
 class Repository
 {
   public:
+    /**
+     * @brief A structure that holds both the PEL and corresponding
+     *        OpenBMC IDs.
+     * Used for correlating the IDs with their data files for quick
+     * lookup.  To find a PEL based on just one of the IDs, just use
+     * the constructor that takes that ID.
+     */
+    struct LogID
+    {
+        struct Pel
+        {
+            uint32_t id;
+            explicit Pel(uint32_t i) : id(i)
+            {
+            }
+        };
+        struct Obmc
+        {
+            uint32_t id;
+            explicit Obmc(uint32_t i) : id(i)
+            {
+            }
+        };
+
+        Pel pelID;
+
+        Obmc obmcID;
+
+        LogID(Pel pel, Obmc obmc) : pelID(pel), obmcID(obmc)
+        {
+        }
+
+        explicit LogID(Pel id) : pelID(id), obmcID(0)
+        {
+        }
+
+        explicit LogID(Obmc id) : pelID(0), obmcID(id)
+        {
+        }
+
+        LogID() = delete;
+
+        /**
+         * @brief A == operator that will match on either ID
+         *        being equal if the other is zero, so that
+         *        one can look up a PEL with just one of the IDs.
+         */
+        bool operator==(const LogID& id) const
+        {
+            if (id.pelID.id != 0)
+            {
+                return id.pelID.id == pelID.id;
+            }
+            if (id.obmcID.id != 0)
+            {
+                return id.obmcID.id == obmcID.id;
+            }
+            return false;
+        }
+
+        bool operator<(const LogID& id) const
+        {
+            return pelID.id < id.pelID.id;
+        }
+    };
+
     Repository() = delete;
     ~Repository() = default;
     Repository(const Repository&) = default;
@@ -42,6 +109,13 @@
     void add(std::unique_ptr<PEL>& pel);
 
     /**
+     * @brief Removes a PEL from the repository
+     *
+     * @param[in] id - the ID (either the pel ID, OBMC ID, or both) to remove
+     */
+    void remove(const LogID& id);
+
+    /**
      * @brief Generates the filename to use for the PEL ID and BCDTime.
      *
      * @param[in] pelID - the PEL ID
@@ -51,11 +125,46 @@
      */
     static std::string getPELFilename(uint32_t pelID, const BCDTime& time);
 
+    /**
+     * @brief Returns true if the PEL with the specified ID is in the repo.
+     *
+     * @param[in] id - the ID (either the pel ID, OBMC ID, or both)
+     * @return bool - true if that PEL is present
+     */
+    inline bool hasPEL(const LogID& id)
+    {
+        return findPEL(id) != _idsToPELs.end();
+    }
+
   private:
     /**
+     * @brief Finds an entry in the _idsToPELs map.
+     *
+     * @param[in] id - the ID (either the pel ID, OBMC ID, or both)
+     *
+     * @return an iterator to the entry
+     */
+    std::map<LogID, std::filesystem::path>::iterator findPEL(const LogID& id)
+    {
+        return std::find_if(_idsToPELs.begin(), _idsToPELs.end(),
+                            [&id](const auto& i) { return i.first == id; });
+    }
+
+    /**
+     * @brief Restores the _idsToPELs map on startup based on the existing
+     *        PEL data files.
+     */
+    void restore();
+
+    /**
      * @brief The filesystem path to the PEL logs.
      */
     const std::filesystem::path _logPath;
+
+    /**
+     * @brief A map of the PEL/OBMC IDs to the PEL data files.
+     */
+    std::map<LogID, std::filesystem::path> _idsToPELs;
 };
 
 } // namespace pels
diff --git a/test/openpower-pels/pel_manager_test.cpp b/test/openpower-pels/pel_manager_test.cpp
index a5b16f5..9d788c9 100644
--- a/test/openpower-pels/pel_manager_test.cpp
+++ b/test/openpower-pels/pel_manager_test.cpp
@@ -62,5 +62,21 @@
 
     EXPECT_TRUE(found);
 
+    // Now remove it based on its OpenBMC event log ID
+    manager.erase(42);
+
+    found = false;
+
+    for (auto& f : fs::directory_iterator(getPELRepoPath() / "logs"))
+    {
+        if (std::regex_search(f.path().string(), expr))
+        {
+            found = true;
+            break;
+        }
+    }
+
+    EXPECT_FALSE(found);
+
     fs::remove_all(pelFilename.parent_path());
 }
diff --git a/test/openpower-pels/repository_test.cpp b/test/openpower-pels/repository_test.cpp
index 97019e8..6963184 100644
--- a/test/openpower-pels/repository_test.cpp
+++ b/test/openpower-pels/repository_test.cpp
@@ -71,3 +71,70 @@
     auto pelData = pel->data();
     EXPECT_EQ(*newData, pelData);
 }
+
+TEST_F(RepositoryTest, RestoreTest)
+{
+    using pelID = Repository::LogID::Pel;
+    using obmcID = Repository::LogID::Obmc;
+
+    std::vector<Repository::LogID> ids;
+
+    {
+        Repository repo{repoPath};
+
+        // Add some PELs to the repository
+        {
+            auto data = pelDataFactory(TestPelType::pelSimple);
+            auto pel = std::make_unique<PEL>(*data, 1);
+            pel->assignID();
+            repo.add(pel);
+            ids.emplace_back(pelID(pel->id()), obmcID(1));
+        }
+        {
+            auto data = pelDataFactory(TestPelType::pelSimple);
+            auto pel = std::make_unique<PEL>(*data, 2);
+            pel->assignID();
+            repo.add(pel);
+            ids.emplace_back(pelID(pel->id()), obmcID(2));
+        }
+
+        // Check they're there
+        EXPECT_TRUE(repo.hasPEL(ids[0]));
+        EXPECT_TRUE(repo.hasPEL(ids[1]));
+
+        // Do some other search tests while we're here.
+
+        // Search based on PEL ID
+        Repository::LogID id(pelID(ids[0].pelID));
+        EXPECT_TRUE(repo.hasPEL(id));
+
+        // Search based on OBMC log ID
+        id.pelID.id = 0;
+        id.obmcID = ids[0].obmcID;
+        EXPECT_TRUE(repo.hasPEL(id));
+
+        // ... based on the other PEL ID
+        id.pelID = ids[1].pelID;
+        id.obmcID.id = 0;
+        EXPECT_TRUE(repo.hasPEL(id));
+
+        // Not found
+        id.pelID.id = 99;
+        id.obmcID.id = 100;
+        EXPECT_FALSE(repo.hasPEL(id));
+    }
+
+    {
+        // Restore and check they're still there, then
+        // remove them.
+        Repository repo{repoPath};
+        EXPECT_TRUE(repo.hasPEL(ids[0]));
+        EXPECT_TRUE(repo.hasPEL(ids[1]));
+
+        repo.remove(ids[0]);
+        EXPECT_FALSE(repo.hasPEL(ids[0]));
+
+        repo.remove(ids[1]);
+        EXPECT_FALSE(repo.hasPEL(ids[1]));
+    }
+}