diff --git a/mainapp.cpp b/mainapp.cpp
index 35ef255..abd4777 100644
--- a/mainapp.cpp
+++ b/mainapp.cpp
@@ -130,6 +130,10 @@
                  "Should we reset the time remaining any time a postcode "
                  "is signaled.");
 
+    uint64_t minInterval = phosphor::watchdog::DEFAULT_MIN_INTERVAL_MS;
+    app.add_flag("-m,--min_interval", minInterval,
+                 "Set minimum interval for watchdog");
+
     CLI11_PARSE(app, argc, argv);
 
     // Put together a list of actions and associated systemd targets
@@ -218,7 +222,7 @@
 
         // Create a watchdog object
         Watchdog watchdog(bus, path.c_str(), event, std::move(actionTargetMap),
-                          std::move(maybeFallback));
+                          std::move(maybeFallback), minInterval);
 
         std::optional<sdbusplus::bus::match::match> watchPostcodeMatch;
         if (watchPostcodes)
diff --git a/test/watchdog.cpp b/test/watchdog.cpp
index 55502c2..b557e62 100644
--- a/test/watchdog.cpp
+++ b/test/watchdog.cpp
@@ -4,7 +4,10 @@
 #include <thread>
 #include <utility>
 
-using namespace phosphor::watchdog;
+namespace phosphor
+{
+namespace watchdog
+{
 
 WdogTest::Quantum WdogTest::waitForWatchdog(Quantum timeLimit)
 {
@@ -354,8 +357,13 @@
     fallback.interval = static_cast<uint64_t>(fallbackIntervalMs);
     fallback.always = true;
     wdog = std::make_unique<Watchdog>(bus, TEST_PATH, event,
-                                      Watchdog::ActionTargetMap(),
-                                      std::move(fallback));
+                                      Watchdog::ActionTargetMap(), fallback,
+                                      milliseconds(TEST_MIN_INTERVAL).count());
+
+    // Make sure defualt interval is biggger than min interval
+    EXPECT_LT(milliseconds((TEST_MIN_INTERVAL).count()),
+              milliseconds(wdog->interval()));
+
     EXPECT_EQ(primaryInterval, milliseconds(wdog->interval(primaryIntervalMs)));
     EXPECT_FALSE(wdog->enabled());
     auto remaining = milliseconds(wdog->timeRemaining());
@@ -390,3 +398,46 @@
     EXPECT_FALSE(wdog->timerExpired());
     EXPECT_TRUE(wdog->timerEnabled());
 }
+
+/** @brief Test minimal interval
+ *  The minimal interval was set 2 seconds
+ *  Test that when setting interval to 1s , it is still returning 2s
+ */
+TEST_F(WdogTest, verifyMinIntervalSetting)
+{
+    auto newInterval = Quantum(1);
+    auto newIntervalMs = milliseconds(newInterval).count();
+    auto minIntervalMs = milliseconds(TEST_MIN_INTERVAL).count();
+
+    // Check first that the current interval is greater than minInterval
+    EXPECT_LT(minIntervalMs, wdog->interval());
+    // Check that the interval was not set to smaller value than minInterval
+    EXPECT_EQ(minIntervalMs, wdog->interval(newIntervalMs));
+    // Check that the interval was not set to smaller value than minInterval
+    EXPECT_EQ(minIntervalMs, wdog->interval());
+}
+
+/** @brief Test minimal interval
+ *  Initiate default Watchdog in order to get the default
+ *  interval.
+ *  Initiate watchdog with minInterval greater than default
+ *  interval, and make sure the default interval was set to the
+ *  minInterval.
+ */
+TEST_F(WdogTest, verifyConstructorMinIntervalSetting)
+{
+    // Initiate default Watchdog and get the default interval value.
+    wdog = std::make_unique<Watchdog>(bus, TEST_PATH, event);
+    auto defaultInterval = wdog->interval();
+    auto minInterval = defaultInterval + 100;
+    // We initiate a new Watchdog with min interval greater than the default
+    // intrval
+    wdog = std::make_unique<Watchdog>(bus, TEST_PATH, event,
+                                      Watchdog::ActionTargetMap(), std::nullopt,
+                                      minInterval);
+    // Check that the interval was set to the minInterval
+    EXPECT_EQ(minInterval, wdog->interval());
+}
+
+} // namespace watchdog
+} // namespace phosphor
diff --git a/test/watchdog.hpp b/test/watchdog.hpp
index df628c3..87166f4 100644
--- a/test/watchdog.hpp
+++ b/test/watchdog.hpp
@@ -7,9 +7,16 @@
 
 #include <gtest/gtest.h>
 
+namespace phosphor
+{
+namespace watchdog
+{
+
 using namespace std::chrono;
 using namespace std::chrono_literals;
 
+constexpr auto TEST_MIN_INTERVAL = duration<uint64_t, std::deci>(2);
+
 // Test Watchdog functionality
 class WdogTest : public ::testing::Test
 {
@@ -22,9 +29,12 @@
     WdogTest() :
         event(sdeventplus::Event::get_default()),
         bus(sdbusplus::bus::new_default()),
-        wdog(std::make_unique<phosphor::watchdog::Watchdog>(bus, TEST_PATH,
-                                                            event)),
+        wdog(std::make_unique<Watchdog>(
+            bus, TEST_PATH, event, Watchdog::ActionTargetMap(), std::nullopt,
+            milliseconds(TEST_MIN_INTERVAL).count())),
+
         defaultInterval(Quantum(3))
+
     {
         wdog->interval(milliseconds(defaultInterval).count());
         // Initially the watchdog would be disabled
@@ -38,7 +48,7 @@
     sdbusplus::bus::bus bus;
 
     // Watchdog object
-    std::unique_ptr<phosphor::watchdog::Watchdog> wdog;
+    std::unique_ptr<Watchdog> wdog;
 
     // This is the default interval as given in Interface definition
     Quantum defaultInterval;
@@ -53,3 +63,6 @@
     // disabled or have its timeRemaining reset.
     Quantum waitForWatchdog(Quantum timeLimit);
 };
+
+} // namespace watchdog
+} // namespace phosphor
diff --git a/watchdog.cpp b/watchdog.cpp
index bc3ba95..9090760 100644
--- a/watchdog.cpp
+++ b/watchdog.cpp
@@ -1,5 +1,6 @@
 #include "watchdog.hpp"
 
+#include <algorithm>
 #include <chrono>
 #include <phosphor-logging/elog.hpp>
 #include <phosphor-logging/log.hpp>
@@ -92,6 +93,12 @@
     return WatchdogInherits::timeRemaining(value);
 }
 
+// Set value of Interval
+uint64_t Watchdog::interval(uint64_t value)
+{
+    return WatchdogInherits::interval(std::max(value, minInterval));
+}
+
 // Optional callback function on timer expiration
 void Watchdog::timeOutHandler()
 {
diff --git a/watchdog.hpp b/watchdog.hpp
index 34b0411..7de9bb3 100644
--- a/watchdog.hpp
+++ b/watchdog.hpp
@@ -15,6 +15,7 @@
 namespace watchdog
 {
 
+constexpr auto DEFAULT_MIN_INTERVAL_MS = 0;
 namespace Base = sdbusplus::xyz::openbmc_project::State::server;
 using WatchdogInherits = sdbusplus::server::object::object<Base::Watchdog>;
 
@@ -62,12 +63,15 @@
     Watchdog(sdbusplus::bus::bus& bus, const char* objPath,
              const sdeventplus::Event& event,
              ActionTargetMap&& actionTargetMap = {},
-             std::optional<Fallback>&& fallback = std::nullopt) :
+             std::optional<Fallback>&& fallback = std::nullopt,
+             uint64_t minInterval = DEFAULT_MIN_INTERVAL_MS) :
         WatchdogInherits(bus, objPath),
         bus(bus), actionTargetMap(std::move(actionTargetMap)),
-        fallback(std::move(fallback)),
+        fallback(std::move(fallback)), minInterval(minInterval),
         timer(event, std::bind(&Watchdog::timeOutHandler, this))
     {
+        // We set the watchdog interval with the default value.
+        interval(interval());
         // We need to poke the enable mechanism to make sure that the timer
         // enters the fallback state if the fallback is always enabled.
         tryFallbackOrDisable();
@@ -116,6 +120,23 @@
      */
     uint64_t timeRemaining(uint64_t value) override;
 
+    /** @brief Get value of Interval
+     *
+     *
+     *  @return: current interval
+     *
+     */
+    using WatchdogInherits::interval;
+
+    /** @brief Set value of Interval
+     *
+     *  @param[in] value - interval time to set
+     *
+     *  @return: interval that was set
+     *
+     */
+    uint64_t interval(uint64_t value);
+
     /** @brief Tells if the referenced timer is expired or not */
     inline auto timerExpired() const
     {
@@ -138,6 +159,9 @@
     /** @brief Fallback timer options */
     std::optional<Fallback> fallback;
 
+    /** @brief Minimum watchdog interval value */
+    uint64_t minInterval;
+
     /** @brief Contained timer object */
     sdeventplus::utility::Timer<sdeventplus::ClockId::Monotonic> timer;