diff --git a/pid/fancontroller.cpp b/pid/fancontroller.cpp
index 33e2d9f..57902ab 100644
--- a/pid/fancontroller.cpp
+++ b/pid/fancontroller.cpp
@@ -159,6 +159,12 @@
         auto redundantWrite = _owner->getRedundantWrite();
         int64_t rawWritten;
         sensor->write(percent, redundantWrite, &rawWritten);
+
+        // The outputCache will be used later,
+        // to store a record of the PWM commanded,
+        // so that this information can be included during logging.
+        auto unscaledWritten = static_cast<double>(rawWritten);
+        _owner->setOutputCache(sensor->getName(), {percent, unscaledWritten});
     }
 
     return;
diff --git a/pid/zone.cpp b/pid/zone.cpp
index 1eda992..585cbeb 100644
--- a/pid/zone.cpp
+++ b/pid/zone.cpp
@@ -153,9 +153,20 @@
 
 double DbusPidZone::getCachedValue(const std::string& name)
 {
+    return _cachedValuesByName.at(name).scaled;
+}
+
+ValueCacheEntry DbusPidZone::getCachedValues(const std::string& name)
+{
     return _cachedValuesByName.at(name);
 }
 
+void DbusPidZone::setOutputCache(std::string_view name,
+                                 const ValueCacheEntry& values)
+{
+    _cachedFanOutputs[std::string{name}] = values;
+}
+
 void DbusPidZone::addFanInput(const std::string& fan)
 {
     _fanInputs.push_back(fan);
@@ -284,29 +295,28 @@
 void DbusPidZone::initializeLog(void)
 {
     /* Print header for log file:
-     * epoch_ms,setpt,fan1,fan2,fanN,sensor1,sensor2,sensorN,failsafe
+     * epoch_ms,setpt,fan1,fan1_raw,fan1_pwm,fan1_pwm_raw,fan2,fan2_raw,fan2_pwm,fan2_pwm_raw,fanN,fanN_raw,fanN_pwm,fanN_pwm_raw,sensor1,sensor1_raw,sensor2,sensor2_raw,sensorN,sensorN_raw,failsafe
      */
 
     _log << "epoch_ms,setpt,requester";
 
     for (const auto& f : _fanInputs)
     {
-        _log << "," << f;
+        _log << "," << f << "," << f << "_raw";
+        _log << "," << f << "_pwm," << f << "_pwm_raw";
     }
     for (const auto& t : _thermalInputs)
     {
-        _log << "," << t;
+        _log << "," << t << "," << t << "_raw";
     }
+
     _log << ",failsafe";
     _log << std::endl;
-
-    return;
 }
 
 void DbusPidZone::writeLog(const std::string& value)
 {
     _log << value;
-    return;
 }
 
 /*
@@ -342,7 +352,7 @@
     {
         auto sensor = _mgr.getSensor(f);
         ReadReturn r = sensor->read();
-        _cachedValuesByName[f] = r.value;
+        _cachedValuesByName[f] = {r.value, r.unscaled};
         int64_t timeout = sensor->getTimeout();
         tstamp then = r.updated;
 
@@ -357,7 +367,10 @@
          */
         if (loggingEnabled)
         {
-            _log << "," << r.value;
+            const auto& v = _cachedValuesByName[f];
+            _log << "," << v.scaled << "," << v.unscaled;
+            const auto& p = _cachedFanOutputs[f];
+            _log << "," << p.scaled << "," << p.unscaled;
         }
 
         // check if fan fail.
@@ -384,7 +397,8 @@
     {
         for (const auto& t : _thermalInputs)
         {
-            _log << "," << _cachedValuesByName[t];
+            const auto& v = _cachedValuesByName[t];
+            _log << "," << v.scaled << "," << v.unscaled;
         }
     }
 
@@ -403,7 +417,7 @@
         ReadReturn r = sensor->read();
         int64_t timeout = sensor->getTimeout();
 
-        _cachedValuesByName[t] = r.value;
+        _cachedValuesByName[t] = {r.value, r.unscaled};
         tstamp then = r.updated;
 
         auto duration = duration_cast<std::chrono::seconds>(now - then).count();
@@ -434,9 +448,12 @@
 
 void DbusPidZone::initializeCache(void)
 {
+    auto nan = std::numeric_limits<double>::quiet_NaN();
+
     for (const auto& f : _fanInputs)
     {
-        _cachedValuesByName[f] = 0;
+        _cachedValuesByName[f] = {nan, nan};
+        _cachedFanOutputs[f] = {nan, nan};
 
         // Start all fans in fail-safe mode.
         _failSafeSensors.insert(f);
@@ -444,7 +461,7 @@
 
     for (const auto& t : _thermalInputs)
     {
-        _cachedValuesByName[t] = 0;
+        _cachedValuesByName[t] = {nan, nan};
 
         // Start all sensors in fail-safe mode.
         _failSafeSensors.insert(t);
@@ -456,7 +473,15 @@
     std::cerr << "Cache values now: \n";
     for (const auto& [name, value] : _cachedValuesByName)
     {
-        std::cerr << name << ": " << value << "\n";
+        std::cerr << name << ": " << value.scaled << " " << value.unscaled
+                  << "\n";
+    }
+
+    std::cerr << "Fan outputs now: \n";
+    for (const auto& [name, value] : _cachedFanOutputs)
+    {
+        std::cerr << name << ": " << value.scaled << " " << value.unscaled
+                  << "\n";
     }
 }
 
diff --git a/pid/zone.hpp b/pid/zone.hpp
index 12e47a6..179b24d 100644
--- a/pid/zone.hpp
+++ b/pid/zone.hpp
@@ -74,6 +74,7 @@
     void updateFanTelemetry(void) override;
     void updateSensors(void) override;
     void initializeCache(void) override;
+    void setOutputCache(std::string_view, const ValueCacheEntry&) override;
     void dumpCache(void);
 
     void processFans(void) override;
@@ -82,6 +83,8 @@
     void addFanPID(std::unique_ptr<Controller> pid);
     void addThermalPID(std::unique_ptr<Controller> pid);
     double getCachedValue(const std::string& name) override;
+    ValueCacheEntry getCachedValues(const std::string& name) override;
+
     void addFanInput(const std::string& fan);
     void addThermalInput(const std::string& therm);
 
@@ -111,7 +114,8 @@
     std::vector<double> _RPMCeilings;
     std::vector<std::string> _fanInputs;
     std::vector<std::string> _thermalInputs;
-    std::map<std::string, double> _cachedValuesByName;
+    std::map<std::string, ValueCacheEntry> _cachedValuesByName;
+    std::map<std::string, ValueCacheEntry> _cachedFanOutputs;
     const SensorManager& _mgr;
 
     std::vector<std::unique_ptr<Controller>> _fans;
diff --git a/pid/zone_interface.hpp b/pid/zone_interface.hpp
index 982e051..7d59497 100644
--- a/pid/zone_interface.hpp
+++ b/pid/zone_interface.hpp
@@ -42,8 +42,23 @@
      */
     virtual void initializeCache(void) = 0;
 
+    /** Optionally adds fan outputs to an output cache, which is different
+     * from the input cache accessed by getCachedValue(), so it is possible
+     * to have entries with the same name in both the output cache and
+     * the input cache. The output cache is used for logging, to show
+     * the PWM values determined by the PID loop, next to the resulting RPM.
+     */
+    virtual void setOutputCache(std::string_view name,
+                                const ValueCacheEntry& values) = 0;
+
     /** Return cached value for sensor by name. */
     virtual double getCachedValue(const std::string& name) = 0;
+    /** Return cached values, both scaled and original unscaled values,
+     * for sensor by name. Subclasses can add trivial return {value, value},
+     * for subclasses that only implement getCachedValue() and do not care
+     * about maintaining the distinction between scaled and unscaled values.
+     */
+    virtual ValueCacheEntry getCachedValues(const std::string& name) = 0;
 
     /** Add a set point value for the Max Set Point computation. */
     virtual void addSetPoint(double setpoint, const std::string& name) = 0;