diff --git a/presence/error_reporter.cpp b/presence/error_reporter.cpp
index 7ff71ae..a73d08b 100644
--- a/presence/error_reporter.cpp
+++ b/presence/error_reporter.cpp
@@ -15,6 +15,13 @@
  */
 #include "error_reporter.hpp"
 
+#include "logging.hpp"
+#include "psensor.hpp"
+#include "utility.hpp"
+
+#include <fmt/format.h>
+#include <unistd.h>
+
 #include <phosphor-logging/log.hpp>
 
 namespace phosphor::fan::presence
@@ -22,14 +29,57 @@
 
 using json = nlohmann::json;
 using namespace phosphor::logging;
+using namespace sdbusplus::bus::match;
+using namespace std::literals::string_literals;
+namespace fs = std::filesystem;
+
+const auto itemIface = "xyz.openbmc_project.Inventory.Item"s;
+const auto invPrefix = "/xyz/openbmc_project/inventory"s;
 
 ErrorReporter::ErrorReporter(
     sdbusplus::bus::bus& bus, const json& jsonConf,
     const std::vector<
         std::tuple<Fan, std::vector<std::unique_ptr<PresenceSensor>>>>& fans) :
-    _bus(bus)
+    _bus(bus),
+    _event(sdeventplus::Event::get_default())
 {
     loadConfig(jsonConf);
+
+    // If different methods to check the power state are needed across the
+    // various platforms, the method/class to use could be read out of JSON
+    // or set with a compilation flag.
+    _powerState = std::make_unique<PGoodState>(
+        bus, std::bind(std::mem_fn(&ErrorReporter::powerStateChanged), this,
+                       std::placeholders::_1));
+
+    for (const auto& fan : fans)
+    {
+        auto path = invPrefix + std::get<1>(std::get<0>(fan));
+
+        // Register for fan presence changes, get their initial states,
+        // and create the fan missing timers for each fan.
+
+        _matches.emplace_back(
+            _bus, rules::propertiesChanged(path, itemIface),
+            std::bind(std::mem_fn(&ErrorReporter::presenceChanged), this,
+                      std::placeholders::_1));
+
+        _fanStates.emplace(path, getPresence(std::get<0>(fan)));
+
+        auto timer = std::make_unique<
+            sdeventplus::utility::Timer<sdeventplus::ClockId::Monotonic>>(
+            _event,
+            std::bind(std::mem_fn(&ErrorReporter::fanMissingTimerExpired), this,
+                      path));
+
+        _fanMissingTimers.emplace(path, std::move(timer));
+    }
+
+    // If power is already on, check for currently missing fans.
+    if (_powerState->isPowerOn())
+    {
+        powerStateChanged(true);
+    }
 }
 
 void ErrorReporter::loadConfig(const json& jsonConf)
@@ -46,4 +96,77 @@
         jsonConf.at("fan_missing_error_time").get<std::size_t>()};
 }
 
+void ErrorReporter::presenceChanged(sdbusplus::message::message& msg)
+{
+    bool present;
+    auto fanPath = msg.get_path();
+    std::string interface;
+    std::map<std::string, std::variant<bool>> properties;
+
+    msg.read(interface, properties);
+
+    auto presentProp = properties.find("Present");
+    if (presentProp != properties.end())
+    {
+        present = std::get<bool>(presentProp->second);
+        if (_fanStates[fanPath] != present)
+        {
+            getLogger().log(fmt::format("Fan {} presence state change to {}",
+                                        fanPath, present));
+
+            _fanStates[fanPath] = present;
+            checkFan(fanPath);
+        }
+    }
+}
+
+void ErrorReporter::checkFan(const std::string& fanPath)
+{
+    if (!_fanStates[fanPath])
+    {
+        // Fan is missing. If power is on, start the timer.
+        // If power is off, stop a running timer.
+        if (_powerState->isPowerOn())
+        {
+            _fanMissingTimers[fanPath]->restartOnce(_fanMissingErrorTime);
+        }
+        else if (_fanMissingTimers[fanPath]->isEnabled())
+        {
+            _fanMissingTimers[fanPath]->setEnabled(false);
+        }
+    }
+    else
+    {
+        // Fan is present. Stop a running timer.
+        if (_fanMissingTimers[fanPath]->isEnabled())
+        {
+            _fanMissingTimers[fanPath]->setEnabled(false);
+        }
+    }
+}
+
+void ErrorReporter::fanMissingTimerExpired(const std::string& fanPath)
+{}
+
+void ErrorReporter::powerStateChanged(bool powerState)
+{
+    if (powerState)
+    {
+        // If there are fans already missing, log it.
+        auto missing = std::count_if(
+            _fanStates.begin(), _fanStates.end(),
+            [](const auto& fanState) { return fanState.second == false; });
+
+        if (missing)
+        {
+            getLogger().log(
+                fmt::format("At power on, there are {} missing fans", missing));
+        }
+    }
+
+    std::for_each(
+        _fanStates.begin(), _fanStates.end(),
+        [this](const auto& fanState) { this->checkFan(fanState.first); });
+}
+
 } // namespace phosphor::fan::presence
diff --git a/presence/error_reporter.hpp b/presence/error_reporter.hpp
index 251aa7e..398cd1f 100644
--- a/presence/error_reporter.hpp
+++ b/presence/error_reporter.hpp
@@ -1,9 +1,13 @@
 #pragma once
 
 #include "fan.hpp"
+#include "power_state.hpp"
 
 #include <nlohmann/json.hpp>
 #include <sdbusplus/bus.hpp>
+#include <sdbusplus/bus/match.hpp>
+#include <sdeventplus/clock.hpp>
+#include <sdeventplus/utility/timer.hpp>
 
 namespace phosphor::fan::presence
 {
@@ -53,15 +57,80 @@
     void loadConfig(const nlohmann::json& jsonConf);
 
     /**
+     * @brief The propertiesChanged callback for the interface that
+     *        contains the Present property of a fan.
+     *
+     * Will start the timer to create an event log if power is on.
+     *
+     * @param[in] msg - The payload of the propertiesChanged signal
+     */
+    void presenceChanged(sdbusplus::message::message& msg);
+
+    /**
+     * @brief The callback function called by the PowerState class
+     *        when the power state changes.
+     *
+     * Will start timers for missing fans if power is on, and stop
+     * them when power changes to off.
+     *
+     * @param[in] powerState - The new power state
+     */
+    void powerStateChanged(bool powerState);
+
+    /**
+     * @brief Called when the fan missing timer expires to create
+     *        an event log for a missing fan.
+     *
+     * @param[in] fanPath - The D-Bus path of the missing fan.
+     */
+    void fanMissingTimerExpired(const std::string& fanPath);
+
+    /**
+     * @brief Checks if the fan missing timer for a fan needs to
+     *        either be started or stopped based on the power and
+     *        presence states.
+     *
+     * @param[in] fanPath - The D-Bus path of the fan
+     */
+    void checkFan(const std::string& fanPath);
+
+    /**
      * @brief Reference to the D-Bus connection object.
      */
     sdbusplus::bus::bus& _bus;
 
     /**
+     * @brief The connection to the event loop for the timer.
+     */
+    sdeventplus::Event _event;
+
+    /**
+     * @brief The propertiesChanged match objects.
+     */
+    std::vector<sdbusplus::bus::match::match> _matches;
+
+    /**
+     * @brief Base class pointer to the power state implementation.
+     */
+    std::unique_ptr<PowerState> _powerState;
+
+    /**
      * @brief The amount of time in seconds that a fan must be missing
      *        before an event log is created for it.
      */
     std::chrono::seconds _fanMissingErrorTime;
+
+    /**
+     * @brief The map of fan paths to their presence states.
+     */
+    std::map<std::string, bool> _fanStates;
+
+    /**
+     * @brief The map of fan paths to their Timer objects.
+     */
+    std::map<std::string, std::unique_ptr<sdeventplus::utility::Timer<
+                              sdeventplus::ClockId::Monotonic>>>
+        _fanMissingTimers;
 };
 
 } // namespace phosphor::fan::presence
diff --git a/presence/fan.cpp b/presence/fan.cpp
index 214ad1b..9ea83f3 100644
--- a/presence/fan.cpp
+++ b/presence/fan.cpp
@@ -59,8 +59,8 @@
 
 bool getPresence(const Fan& fan)
 {
-    return util::SDBusPlus::getProperty<bool>(std::get<1>(fan), itemIface,
-                                              "Present"s);
+    return util::SDBusPlus::getProperty<bool>(invNamespace + std::get<1>(fan),
+                                              itemIface, "Present"s);
 }
 
 } // namespace presence