diff --git a/item_updater.cpp b/item_updater.cpp
index 014757d..6d90579 100644
--- a/item_updater.cpp
+++ b/item_updater.cpp
@@ -283,7 +283,7 @@
     auto it = versions.find(entryId);
     if (it != versions.end())
     {
-        if (it->second->isFunctional())
+        if (it->second->isFunctional() && ACTIVE_BMC_MAX_ALLOWED > 1)
         {
             log<level::ERR>("Error: Version is currently running on the BMC. "
                             "Unable to remove.",
@@ -599,7 +599,10 @@
             count++;
             // Don't put the functional version on the queue since we can't
             // remove the "running" BMC version.
-            if (versions.find(iter.second->versionId)->second->isFunctional())
+            // If ACTIVE_BMC_MAX_ALLOWED <= 1, there is only one active BMC,
+            // so remove functional version as well.
+            if (versions.find(iter.second->versionId)->second->isFunctional() &&
+                ACTIVE_BMC_MAX_ALLOWED > 1)
             {
                 continue;
             }
