diff --git a/configure.ac b/configure.ac
index f5e8b3a..d0adf4e 100644
--- a/configure.ac
+++ b/configure.ac
@@ -70,5 +70,16 @@
 AS_IF([test "x$MAX_EVENTS" == "x"], [MAX_EVENTS=20])
 AC_DEFINE_UNQUOTED([MAX_EVENTS], [$MAX_EVENTS], [Maximum number of events.])
 
+AC_ARG_VAR(CLASS_VERSION, [Class version to register with Cereal])
+AS_IF([test "x$CLASS_VERSION" == "x"], [CLASS_VERSION=1])
+AC_DEFINE_UNQUOTED([CLASS_VERSION], [$CLASS_VERSION], [Class version to register with Cereal])
+
+AC_ARG_VAR(EVENTS_PERSIST_PATH, [Path of directory housing persisted events.])
+AS_IF([test "x$EVENTS_PERSIST_PATH" == "x"], \
+    [EVENTS_PERSIST_PATH="/var/lib/phosphor-dbus-monitor/events"])
+AC_DEFINE_UNQUOTED([EVENTS_PERSIST_PATH], ["$EVENTS_PERSIST_PATH"], \
+    [Path of directory housing persisted events])
+
+
 AC_CONFIG_FILES([Makefile src/Makefile src/test/Makefile mslverify/Makefile])
 AC_OUTPUT
diff --git a/src/Makefile.am b/src/Makefile.am
index 73ebca8..e5827e6 100644
--- a/src/Makefile.am
+++ b/src/Makefile.am
@@ -11,7 +11,9 @@
 	main.cpp \
 	propertywatch.cpp \
 	resolve_errors.cpp \
-	event_manager.cpp
+	event_manager.cpp \
+	event_serialize.cpp
+
 phosphor_dbus_monitor_LDADD = \
 	$(SDBUSPLUS_LIBS) \
 	$(PHOSPHOR_DBUS_INTERFACES_LIBS) \
diff --git a/src/event_entry.hpp b/src/event_entry.hpp
index e39f1e2..899e5ec 100644
--- a/src/event_entry.hpp
+++ b/src/event_entry.hpp
@@ -50,6 +50,17 @@
         this->emit_object_added();
     }
 
+    /** @brief Constructor to create an empty event object with only
+     *  timestamp, caller should make a call to emit added signal.
+     *  @param[in] path - Path to attach at.
+     *  @param[in] timestamp - timestamp when the event created.
+     */
+    Entry(const std::string& path, uint64_t eventTimestamp) :
+        EntryIface(SDBusPlus::getBus(), path.c_str(), true), objectPath(path)
+    {
+        timestamp(eventTimestamp);
+    }
+
     /** @brief Path of Object. */
     std::string objectPath;
 };
diff --git a/src/event_manager.cpp b/src/event_manager.cpp
index 6e7d302..57a8478 100644
--- a/src/event_manager.cpp
+++ b/src/event_manager.cpp
@@ -17,6 +17,7 @@
 #include "config.h"
 #include "event.hpp"
 #include "event_manager.hpp"
+#include "event_serialize.hpp"
 
 #include <experimental/filesystem>
 
@@ -66,13 +67,62 @@
     // event.
     if (eventQueue.size() == MAX_EVENTS)
     {
+        fs::path eventPath(EVENTS_PERSIST_PATH);
+        eventPath /= eventName;
+        eventPath /= std::to_string(eventQueue.front()->timestamp());
         eventQueue.pop();
+        std::error_code ec;
+        fs::remove(eventPath, ec);
     }
 
-    eventQueue.emplace(std::make_unique<Entry>(objPath,
-                                               ms, // Milliseconds since 1970
-                                               std::move(msg),
-                                               std::move(additionalData)));
+    auto event =
+        std::make_unique<Entry>(objPath,
+                                ms, // Milliseconds since 1970
+                                std::move(msg), std::move(additionalData));
+    serialize(*event, eventName);
+    eventQueue.push(std::move(event));
+}
+
+void Manager::restore()
+{
+    if (!fs::exists(EVENTS_PERSIST_PATH) || fs::is_empty(EVENTS_PERSIST_PATH))
+    {
+        return;
+    }
+
+    for (auto& eventFile :
+         fs::recursive_directory_iterator(EVENTS_PERSIST_PATH))
+    {
+        if (!fs::is_regular_file(eventFile))
+        {
+            continue;
+        }
+
+        EventQueue events;
+
+        auto eventPath = eventFile.path().string();
+        auto pos1 = eventPath.rfind("/");
+        auto pos2 = eventPath.rfind("/", pos1 - 1) + 1;
+        auto eventName = eventPath.substr(pos2, (pos1 - pos2));
+        auto validEvent = false;
+        auto timestamp = eventFile.path().filename().string();
+        auto tsNum = std::stoll(timestamp);
+        auto objPath =
+            std::string(OBJ_EVENT) + '/' + eventName + '/' + timestamp;
+
+        auto event = std::make_unique<Entry>(objPath, tsNum);
+        if (deserialize(eventFile.path(), *event))
+        {
+            event->emit_object_added();
+            events.push(std::move(event));
+            validEvent = true;
+        }
+
+        if (validEvent)
+        {
+            eventMap[eventName] = std::move(events);
+        }
+    }
 }
 
 Manager& getManager()
diff --git a/src/event_manager.hpp b/src/event_manager.hpp
index a177739..a4ccf18 100644
--- a/src/event_manager.hpp
+++ b/src/event_manager.hpp
@@ -38,6 +38,11 @@
                 const std::string& objectPath, const std::string& propertyName,
                 const std::string& propertyValue);
 
+    /** @brief Construct event d-bus objects from their persisted
+     *         representations.
+     */
+    void restore();
+
   private:
     using EventName = std::string;
     /** @brief Queue of events */
diff --git a/src/event_serialize.cpp b/src/event_serialize.cpp
new file mode 100644
index 0000000..c7e78d9
--- /dev/null
+++ b/src/event_serialize.cpp
@@ -0,0 +1,97 @@
+#include <cereal/types/string.hpp>
+#include <cereal/types/vector.hpp>
+#include <cereal/archives/binary.hpp>
+#include <fstream>
+
+#include "event_serialize.hpp"
+#include <phosphor-logging/log.hpp>
+#include "config.h"
+
+// Register class version
+// From cereal documentation;
+// "This macro should be placed at global scope"
+CEREAL_CLASS_VERSION(phosphor::events::Entry, CLASS_VERSION);
+
+namespace phosphor
+{
+namespace events
+{
+
+using namespace phosphor::logging;
+
+/** @brief Function required by Cereal to perform serialization.
+ *  @tparam Archive - Cereal archive type (binary in our case).
+ *  @param[in] archive - reference to Cereal archive.
+ *  @param[in] event - const reference to event entry.
+ *  @param[in] version - Class version that enables handling
+ *                       a serialized data across code levels
+ */
+template <class Archive>
+void save(Archive& archive, const Entry& event, const std::uint32_t version)
+{
+    archive(event.timestamp(), event.message(), event.additionalData());
+}
+
+/** @brief Function required by Cereal to perform deserialization.
+ *  @tparam Archive - Cereal archive type (binary in our case).
+ *  @param[in] archive - reference to Cereal archive.
+ *  @param[in] event - reference to event entry.
+ *  @param[in] version - Class version that enables handling
+ *                       a serialized data across code levels
+ */
+template <class Archive>
+void load(Archive& archive, Entry& event, const std::uint32_t version)
+{
+    using namespace sdbusplus::xyz::openbmc_project::Logging::server;
+
+    uint64_t timestamp{};
+    std::string message{};
+    std::vector<std::string> additionalData{};
+
+    archive(timestamp, message, additionalData);
+
+    event.timestamp(timestamp);
+    event.message(message);
+    event.additionalData(additionalData);
+}
+
+fs::path serialize(const Entry& event, const std::string& eventName)
+{
+    fs::path dir(EVENTS_PERSIST_PATH);
+    auto path = dir / eventName;
+    fs::create_directories(path);
+    path /= std::to_string(event.timestamp());
+    std::ofstream os(path.string(), std::ios::binary);
+    cereal::BinaryOutputArchive oarchive(os);
+    oarchive(event);
+    return path;
+}
+
+bool deserialize(const fs::path& path, Entry& event)
+{
+    try
+    {
+        if (fs::exists(path))
+        {
+            std::ifstream is(path.c_str(), std::ios::in | std::ios::binary);
+            cereal::BinaryInputArchive iarchive(is);
+            iarchive(event);
+            return true;
+        }
+        return false;
+    }
+    catch (cereal::Exception& e)
+    {
+        log<level::ERR>(e.what());
+        std::error_code ec;
+        fs::remove(path, ec);
+        return false;
+    }
+    catch (const fs::filesystem_error& e)
+    {
+        return false;
+    }
+}
+
+} // namespace event
+} // namespace phosphor
diff --git a/src/event_serialize.hpp b/src/event_serialize.hpp
new file mode 100644
index 0000000..f052845
--- /dev/null
+++ b/src/event_serialize.hpp
@@ -0,0 +1,30 @@
+#pragma once
+
+#include <experimental/filesystem>
+#include "event_entry.hpp"
+#include "config.h"
+
+namespace phosphor
+{
+namespace events
+{
+
+namespace fs = std::experimental::filesystem;
+
+/** @brief Serialize and persist event d-bus object
+ *  @param[in] event - const reference to event entry.
+ *  @param[in] eventName - Name of the event.
+ *  @return fs::path - pathname of persisted events file
+ */
+fs::path serialize(const Entry& event, const std::string& eventName);
+
+/** @brief Deserialze a persisted event into a d-bus object
+ *  @param[in] path - pathname of persisted event file
+ *  @param[in] event - reference to event object which is the target of
+ *             deserialization.
+ *  @return bool - true if the deserialization was successful, false otherwise.
+ */
+bool deserialize(const fs::path& path, Entry& event);
+
+} // namespace events
+} // namespace phosphor
diff --git a/src/main.cpp b/src/main.cpp
index 5e191e1..68cef3e 100644
--- a/src/main.cpp
+++ b/src/main.cpp
@@ -43,6 +43,8 @@
     sdbusplus::server::manager::manager objManager(bus, OBJ_EVENT);
     bus.request_name(BUSNAME_EVENT);
 
+    phosphor::events::getManager().restore();
+
     for (auto& watch : ConfigPropertyWatches::get())
     {
         watch->start();
diff --git a/src/test/Makefile.am b/src/test/Makefile.am
index 717bacc..8f3cd02 100644
--- a/src/test/Makefile.am
+++ b/src/test/Makefile.am
@@ -199,4 +199,5 @@
 	$(builddir)/../elog.o \
 	$(builddir)/../resolve_errors.o \
 	$(builddir)/../event_manager.o \
+	$(builddir)/../event_serialize.o \
 	-lstdc++fs