diff --git a/power_state.hpp b/power_state.hpp
index d576afe..ee3eff8 100644
--- a/power_state.hpp
+++ b/power_state.hpp
@@ -16,7 +16,8 @@
  *
  * This class provides an interface to check the current power state,
  * and to register a function that gets called when there is a power
- * state change.
+ * state change.  A callback can be passed in using the constructor,
+ * or can be added later using addCallback().
  *
  * Different architectures may have different ways of considering
  * power to be on, such as a pgood property on the
@@ -29,7 +30,6 @@
   public:
     using StateChangeFunc = std::function<void(bool)>;
 
-    PowerState() = delete;
     virtual ~PowerState() = default;
     PowerState(const PowerState&) = delete;
     PowerState& operator=(const PowerState&) = delete;
@@ -43,11 +43,43 @@
      * @param[in] callback - The function that should be run when
      *                       the power state changes
      */
-    PowerState(sdbusplus::bus::bus& bus, StateChangeFunc callback) :
-        _bus(bus), _callback(std::move(callback))
+    PowerState(sdbusplus::bus::bus& bus, StateChangeFunc callback) : _bus(bus)
+    {
+        _callbacks.emplace("default", std::move(callback));
+    }
+
+    /**
+     * @brief Constructor
+     *
+     * Callbacks can be added with addCallback().
+     */
+    PowerState() : _bus(util::SDBusPlus::getBus())
     {}
 
     /**
+     * @brief Adds a function to call when the power state changes
+     *
+     * @param[in] - Any unique name, so the callback can be removed later
+     *              if desired.
+     * @param[in] callback - The function that should be run when
+     *                       the power state changes
+     */
+    void addCallback(const std::string& name, StateChangeFunc callback)
+    {
+        _callbacks.emplace(name, std::move(callback));
+    }
+
+    /**
+     * @brief Remove the callback so it is no longer called
+     *
+     * @param[in] name - The name used when it was added.
+     */
+    void deleteCallback(const std::string& name)
+    {
+        _callbacks.erase(name);
+    }
+
+    /**
      * @brief Says if power is on
      *
      * @return bool - The power state
@@ -61,7 +93,7 @@
     /**
      * @brief Called by derived classes to set the power state value
      *
-     * Will call the callback function if the state changed.
+     * Will call the callback functions if the state changed.
      *
      * @param[in] state - The new power state
      */
@@ -70,7 +102,10 @@
         if (state != _powerState)
         {
             _powerState = state;
-            _callback(_powerState);
+            for (const auto& [name, callback] : _callbacks)
+            {
+                callback(_powerState);
+            }
         }
     }
 
@@ -86,9 +121,9 @@
 
   private:
     /**
-     * @brief The callback function to run when the power state changes
+     * @brief The callback functions to run when the power state changes
      */
-    std::function<void(bool)> _callback;
+    std::map<std::string, StateChangeFunc> _callbacks;
 };
 
 /**
@@ -100,13 +135,21 @@
 class PGoodState : public PowerState
 {
   public:
-    PGoodState() = delete;
     virtual ~PGoodState() = default;
     PGoodState(const PGoodState&) = delete;
     PGoodState& operator=(const PGoodState&) = delete;
     PGoodState(PGoodState&&) = delete;
     PGoodState& operator=(PGoodState&&) = delete;
 
+    PGoodState() :
+        PowerState(), _match(_bus,
+                             sdbusplus::bus::match::rules::propertiesChanged(
+                                 _pgoodPath, _pgoodInterface),
+                             [this](auto& msg) { this->pgoodChanged(msg); })
+    {
+        readPGood();
+    }
+
     /**
      * @brief Constructor
      *
@@ -121,22 +164,7 @@
                                                                _pgoodInterface),
                [this](auto& msg) { this->pgoodChanged(msg); })
     {
-        try
-        {
-            auto pgood = util::SDBusPlus::getProperty<int32_t>(
-                _bus, _pgoodPath, _pgoodInterface, _pgoodProperty);
-
-            _powerState = static_cast<bool>(pgood);
-        }
-        catch (const util::DBusError& e)
-        {
-            using namespace phosphor::logging;
-            log<level::ERR>(
-                fmt::format("Could not find PGOOD interface {} on D-Bus",
-                            _pgoodInterface)
-                    .c_str());
-            throw;
-        }
+        readPGood();
     }
 
     /**
@@ -162,6 +190,29 @@
     }
 
   private:
+    /**
+     * @brief Reads the PGOOD property from D-Bus and saves it.
+     */
+    void readPGood()
+    {
+        try
+        {
+            auto pgood = util::SDBusPlus::getProperty<int32_t>(
+                _bus, _pgoodPath, _pgoodInterface, _pgoodProperty);
+
+            _powerState = static_cast<bool>(pgood);
+        }
+        catch (const util::DBusError& e)
+        {
+            using namespace phosphor::logging;
+            log<level::ERR>(
+                fmt::format("Could not find PGOOD interface {} on D-Bus",
+                            _pgoodInterface)
+                    .c_str());
+            throw;
+        }
+    }
+
     /** @brief D-Bus path constant */
     const std::string _pgoodPath{"/org/openbmc/control/power0"};
 
diff --git a/presence/Makefile.am b/presence/Makefile.am
index 2affa91..b0b00df 100644
--- a/presence/Makefile.am
+++ b/presence/Makefile.am
@@ -19,6 +19,7 @@
 	error_reporter.cpp \
 	fallback.cpp \
 	fan.cpp \
+	get_power_state.cpp \
 	gpio.cpp \
 	logging.cpp \
 	psensor.cpp \
diff --git a/presence/error_reporter.cpp b/presence/error_reporter.cpp
index f1dfaa9..72c7dae 100644
--- a/presence/error_reporter.cpp
+++ b/presence/error_reporter.cpp
@@ -15,6 +15,7 @@
  */
 #include "error_reporter.hpp"
 
+#include "get_power_state.hpp"
 #include "logging.hpp"
 #include "psensor.hpp"
 #include "utility.hpp"
@@ -46,14 +47,12 @@
     const std::vector<
         std::tuple<Fan, std::vector<std::unique_ptr<PresenceSensor>>>>& fans) :
     _bus(bus),
-    _event(sdeventplus::Event::get_default())
+    _event(sdeventplus::Event::get_default()),
+    _powerState(getPowerStateObject())
 {
-    // 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));
+    _powerState->addCallback("errorReporter",
+                             std::bind(&ErrorReporter::powerStateChanged, this,
+                                       std::placeholders::_1));
 
     for (const auto& fan : fans)
     {
diff --git a/presence/error_reporter.hpp b/presence/error_reporter.hpp
index a6a86fe..a8c9d6f 100644
--- a/presence/error_reporter.hpp
+++ b/presence/error_reporter.hpp
@@ -104,7 +104,7 @@
     /**
      * @brief Base class pointer to the power state implementation.
      */
-    std::unique_ptr<PowerState> _powerState;
+    std::shared_ptr<PowerState> _powerState;
 
     /**
      * @brief The map of fan paths to their presence states.
diff --git a/presence/get_power_state.cpp b/presence/get_power_state.cpp
new file mode 100644
index 0000000..f1d913f
--- /dev/null
+++ b/presence/get_power_state.cpp
@@ -0,0 +1,17 @@
+#include "power_state.hpp"
+
+namespace phosphor::fan
+{
+
+std::shared_ptr<PowerState> powerState;
+
+std::shared_ptr<PowerState> getPowerStateObject()
+{
+    if (!powerState)
+    {
+        powerState = std::make_shared<PGoodState>();
+    }
+    return powerState;
+}
+
+} // namespace phosphor::fan
diff --git a/presence/get_power_state.hpp b/presence/get_power_state.hpp
new file mode 100644
index 0000000..422852a
--- /dev/null
+++ b/presence/get_power_state.hpp
@@ -0,0 +1,18 @@
+#pragma once
+
+#include "power_state.hpp"
+
+namespace phosphor::fan
+{
+
+/**
+ * @brief Returns the PowerState object as a shared_ptr.
+ *
+ * Callers can use addCallback() on the return object to
+ * have functions run when the power state changes.
+ *
+ * @return shared_ptr<PowerState>
+ */
+std::shared_ptr<PowerState> getPowerStateObject();
+
+} // namespace phosphor::fan