diff --git a/extensions/openpower-pels/manager.cpp b/extensions/openpower-pels/manager.cpp
index fea2ba9..d7fbcad 100644
--- a/extensions/openpower-pels/manager.cpp
+++ b/extensions/openpower-pels/manager.cpp
@@ -19,6 +19,7 @@
 #include "json_utils.hpp"
 #include "pel.hpp"
 
+#include <sys/inotify.h>
 #include <unistd.h>
 
 #include <filesystem>
@@ -45,6 +46,18 @@
 constexpr auto esel = "ESEL";
 } // namespace additional_data
 
+Manager::~Manager()
+{
+    if (_pelFileDeleteFD != -1)
+    {
+        if (_pelFileDeleteWatchFD != -1)
+        {
+            inotify_rm_watch(_pelFileDeleteFD, _pelFileDeleteWatchFD);
+        }
+        close(_pelFileDeleteFD);
+    }
+}
+
 void Manager::create(const std::string& message, uint32_t obmcLogID,
                      uint64_t timestamp, Entry::Level severity,
                      const std::vector<std::string>& additionalData,
@@ -341,11 +354,9 @@
 
 void Manager::scheduleFDClose(int fd)
 {
-    sdeventplus::Event event = sdeventplus::Event::get_default();
-
     _fdCloserEventSource = std::make_unique<sdeventplus::source::Defer>(
-        event, std::bind(std::mem_fn(&Manager::closeFD), this, fd,
-                         std::placeholders::_1));
+        _event, std::bind(std::mem_fn(&Manager::closeFD), this, fd,
+                          std::placeholders::_1));
 }
 
 void Manager::closeFD(int fd, sdeventplus::source::EventBase& source)
@@ -426,11 +437,9 @@
 
 void Manager::scheduleRepoPrune()
 {
-    sdeventplus::Event event = sdeventplus::Event::get_default();
-
     _repoPrunerEventSource = std::make_unique<sdeventplus::source::Defer>(
-        event, std::bind(std::mem_fn(&Manager::pruneRepo), this,
-                         std::placeholders::_1));
+        _event, std::bind(std::mem_fn(&Manager::pruneRepo), this,
+                          std::placeholders::_1));
 }
 
 void Manager::pruneRepo(sdeventplus::source::EventBase& source)
@@ -444,5 +453,95 @@
     _repoPrunerEventSource.reset();
 }
 
+void Manager::setupPELDeleteWatch()
+{
+    _pelFileDeleteFD = inotify_init1(IN_NONBLOCK);
+    if (-1 == _pelFileDeleteFD)
+    {
+        auto e = errno;
+        std::string msg =
+            "inotify_init1 failed with errno " + std::to_string(e);
+        log<level::ERR>(msg.c_str());
+        abort();
+    }
+
+    _pelFileDeleteWatchFD = inotify_add_watch(
+        _pelFileDeleteFD, _repo.repoPath().c_str(), IN_DELETE);
+    if (-1 == _pelFileDeleteWatchFD)
+    {
+        auto e = errno;
+        std::string msg =
+            "inotify_add_watch failed with error " + std::to_string(e);
+        log<level::ERR>(msg.c_str());
+        abort();
+    }
+
+    _pelFileDeleteEventSource = std::make_unique<sdeventplus::source::IO>(
+        _event, _pelFileDeleteFD, EPOLLIN,
+        std::bind(std::mem_fn(&Manager::pelFileDeleted), this,
+                  std::placeholders::_1, std::placeholders::_2,
+                  std::placeholders::_3));
+}
+
+void Manager::pelFileDeleted(sdeventplus::source::IO& io, int fd,
+                             uint32_t revents)
+{
+    if (!(revents & EPOLLIN))
+    {
+        return;
+    }
+
+    // An event for 1 PEL uses 48B. When all PELs are deleted at once,
+    // as many events as there is room for can be handled in one callback.
+    // A size of 2000 will allow 41 to be processed, with additional
+    // callbacks being needed to process the remaining ones.
+    std::array<uint8_t, 2000> data;
+    auto bytesRead = read(_pelFileDeleteFD, data.data(), data.size());
+    if (bytesRead < 0)
+    {
+        auto e = errno;
+        std::string msg = "Failed reading data from inotify event, errno = " +
+                          std::to_string(e);
+        log<level::ERR>(msg.c_str());
+        abort();
+    }
+
+    auto offset = 0;
+    while (offset < bytesRead)
+    {
+        auto event = reinterpret_cast<inotify_event*>(&data[offset]);
+        if (event->mask & IN_DELETE)
+        {
+            std::string filename{event->name};
+
+            // Get the PEL ID from the filename and tell the
+            // repo it's been removed, and then delete the BMC
+            // event log if it's there.
+            auto pos = filename.find_first_of('_');
+            if (pos != std::string::npos)
+            {
+                try
+                {
+                    auto idString = filename.substr(pos + 1);
+                    auto pelID = std::stoul(idString, nullptr, 16);
+
+                    Repository::LogID id{Repository::LogID::Pel(pelID)};
+                    auto removedLogID = _repo.remove(id);
+                    if (removedLogID)
+                    {
+                        _logManager.erase(removedLogID->obmcID.id);
+                    }
+                }
+                catch (const std::exception& e)
+                {
+                    log<level::INFO>("Could not find PEL ID from its filename",
+                                     entry("FILENAME=%s", filename.c_str()));
+                }
+            }
+        }
+
+        offset += offsetof(inotify_event, name) + event->len;
+    }
+}
 } // namespace pels
 } // namespace openpower
diff --git a/extensions/openpower-pels/manager.hpp b/extensions/openpower-pels/manager.hpp
index 2d443c6..50317a5 100644
--- a/extensions/openpower-pels/manager.hpp
+++ b/extensions/openpower-pels/manager.hpp
@@ -31,7 +31,6 @@
 {
   public:
     Manager() = delete;
-    ~Manager() = default;
     Manager(const Manager&) = default;
     Manager& operator=(const Manager&) = default;
     Manager(Manager&&) = default;
@@ -52,8 +51,10 @@
         _logManager(logManager), _eventLogger(std::move(creatorFunc)),
         _repo(getPELRepoPath()),
         _registry(getPELReadOnlyDataPath() / message::registryFileName),
+        _event(sdeventplus::Event::get_default()),
         _dataIface(std::move(dataIface))
     {
+        setupPELDeleteWatch();
     }
 
     /**
@@ -76,6 +77,11 @@
     }
 
     /**
+     * @brief Destructor
+     */
+    ~Manager();
+
+    /**
      * @brief Creates a PEL based on the OpenBMC event log contents.  If
      *        a PEL was passed in via the RAWPEL specifier in the
      *        additionalData parameter, use that instead.
@@ -271,6 +277,21 @@
     void pruneRepo(sdeventplus::source::EventBase& source);
 
     /**
+     * @brief Sets up an inotify watch to watch for deleted PEL
+     *        files.  Calls pelFileDeleted() when that occurs.
+     */
+    void setupPELDeleteWatch();
+
+    /**
+     * @brief Called when the inotify watch put on the repository directory
+     *        detects a PEL file was deleted.
+     *
+     * Will tell the Repository class about the deleted PEL, and then tell
+     * the log manager class to delete the corresponding OpenBMC event log.
+     */
+    void pelFileDeleted(sdeventplus::source::IO& io, int fd, uint32_t revents);
+
+    /**
      * @brief Reference to phosphor-logging's Manager class
      */
     phosphor::logging::internal::Manager& _logManager;
@@ -292,6 +313,11 @@
     message::Registry _registry;
 
     /**
+     * @brief The Event object this class uses
+     */
+    sdeventplus::Event _event;
+
+    /**
      * @brief The API the PEL sections use to gather data
      */
     std::unique_ptr<DataInterfaceBase> _dataIface;
@@ -313,6 +339,22 @@
      *        running out of space to make room for new ones.
      */
     std::unique_ptr<sdeventplus::source::Defer> _repoPrunerEventSource;
+
+    /**
+     * @brief The even source for watching for deleted PEL files.
+     */
+    std::unique_ptr<sdeventplus::source::IO> _pelFileDeleteEventSource;
+
+    /**
+     * @brief The file descriptor returned by inotify_init1() used
+     *        for watching for deleted PEL files.
+     */
+    int _pelFileDeleteFD = -1;
+
+    /**
+     * @brief The file descriptor returned by inotify_add_watch().
+     */
+    int _pelFileDeleteWatchFD = -1;
 };
 
 } // namespace pels
diff --git a/extensions/openpower-pels/repository.hpp b/extensions/openpower-pels/repository.hpp
index 96f951c..9bb71e4 100644
--- a/extensions/openpower-pels/repository.hpp
+++ b/extensions/openpower-pels/repository.hpp
@@ -404,6 +404,17 @@
      */
     std::vector<uint32_t> prune();
 
+    /**
+     * @brief Returns the path to the directory where the PEL
+     *        files are stored.
+     *
+     * @return std::filesystem::path - The directory path
+     */
+    const std::filesystem::path& repoPath() const
+    {
+        return _logPath;
+    }
+
   private:
     using PELUpdateFunc = std::function<void(PEL&)>;