diff --git a/include/Thresholds.hpp b/include/Thresholds.hpp
index 57d6f52..41eef94 100644
--- a/include/Thresholds.hpp
+++ b/include/Thresholds.hpp
@@ -51,6 +51,7 @@
     bool used;
     Level level;
     Direction direction;
+    bool assert;
 };
 
 using TimerPair = std::pair<struct TimerUsed, boost::asio::deadline_timer>;
@@ -62,7 +63,24 @@
         io(ioService), sensor(sensor)
     {}
 
-    void stopTimer(const Threshold& threshold)
+    bool hasActiveTimer(const Threshold& threshold, bool assert)
+    {
+        for (TimerPair& timer : timers)
+        {
+            if (timer.first.used)
+            {
+                if ((timer.first.level == threshold.level) &&
+                    (timer.first.direction == threshold.direction) &&
+                    (timer.first.assert == assert))
+                {
+                    return true;
+                }
+            }
+        }
+        return false;
+    }
+
+    void stopTimer(const Threshold& threshold, bool assert)
     {
         struct TimerUsed timerUsed = {};
         for (TimerPair& timer : timers)
@@ -71,7 +89,8 @@
             if (timerUsed.used)
             {
                 if ((timerUsed.level == threshold.level) &&
-                    (timerUsed.direction == threshold.direction))
+                    (timerUsed.direction == threshold.direction) &&
+                    (timerUsed.assert == assert))
                 {
                     timer.second.cancel();
                 }
@@ -79,7 +98,7 @@
         }
     }
 
-    void startTimer(const Threshold& threshold, double assertValue)
+    void startTimer(const Threshold& threshold, bool assert, double assertValue)
     {
         struct TimerUsed timerUsed = {};
         constexpr const size_t waitTime = 5;
@@ -98,29 +117,31 @@
             pair = &timers.emplace_back(timerUsed,
                                         boost::asio::deadline_timer(io));
         }
+
         pair->first.used = true;
         pair->first.level = threshold.level;
         pair->first.direction = threshold.direction;
+        pair->first.assert = assert;
         pair->second.expires_from_now(boost::posix_time::seconds(waitTime));
-        pair->second.async_wait(
-            [this, pair, threshold, assertValue](boost::system::error_code ec) {
-                pair->first.used = false;
+        pair->second.async_wait([this, pair, threshold, assert,
+                                 assertValue](boost::system::error_code ec) {
+            pair->first.used = false;
 
-                if (ec == boost::asio::error::operation_aborted)
-                {
-                    return; // we're being canceled
-                }
-                else if (ec)
-                {
-                    std::cerr << "timer error: " << ec.message() << "\n";
-                    return;
-                }
-                if (isPowerOn())
-                {
-                    assertThresholds(sensor, assertValue, threshold.level,
-                                     threshold.direction, true);
-                }
-            });
+            if (ec == boost::asio::error::operation_aborted)
+            {
+                return; // we're being canceled
+            }
+            else if (ec)
+            {
+                std::cerr << "timer error: " << ec.message() << "\n";
+                return;
+            }
+            if (isPowerOn())
+            {
+                assertThresholds(sensor, assertValue, threshold.level,
+                                 threshold.direction, assert);
+            }
+        });
     }
 
     boost::asio::io_service& io;
diff --git a/src/Thresholds.cpp b/src/Thresholds.cpp
index adc1f68..986d183 100644
--- a/src/Thresholds.cpp
+++ b/src/Thresholds.cpp
@@ -352,16 +352,29 @@
     std::vector<ChangeParam> changes = checkThresholds(sensor, sensor->value);
     for (const auto& change : changes)
     {
-        if (change.asserted)
+        // When CPU is powered off, some volatges are expected to
+        // go below low thresholds. Filter these events with thresholdTimer.
+        // 1. always delay the assertion of low events to see if they are
+        //   caused by power off event.
+        // 2. conditional delay the de-assertion of low events if there is
+        //   an existing timer for assertion.
+        // 3. no delays for de-assert of low events if there is an existing
+        //   de-assert for low event. This means 2nd de-assert would happen
+        //   first and when timer expires for the previous one, no additional
+        //   signal will be logged.
+        // 4. no delays for all high events.
+        if (change.threshold.direction == thresholds::Direction::LOW)
         {
-            thresholdTimer.startTimer(change.threshold, change.assertValue);
+            if (change.asserted || thresholdTimer.hasActiveTimer(
+                                       change.threshold, !change.asserted))
+            {
+                thresholdTimer.startTimer(change.threshold, change.asserted,
+                                          change.assertValue);
+                continue;
+            }
         }
-        else
-        {
-            thresholdTimer.stopTimer(change.threshold);
-            assertThresholds(sensor, change.assertValue, change.threshold.level,
-                             change.threshold.direction, false);
-        }
+        assertThresholds(sensor, change.assertValue, change.threshold.level,
+                         change.threshold.direction, change.asserted);
     }
 }