diff --git a/src/miner.cpp b/src/miner.cpp
--- a/src/miner.cpp
+++ b/src/miner.cpp
@@ -222,7 +222,7 @@
     pblock->nBits = GetNextWorkRequired(pindexPrev, pblock, *config);
     pblock->nNonce = 0;
     pblocktemplate->entries[0].txSigOps = GetSigOpCountWithoutP2SH(
-        *pblocktemplate->entries[0].tx, STANDARD_CHECKDATASIG_VERIFY_FLAGS);
+        *pblocktemplate->entries[0].tx, STANDARD_SCRIPT_VERIFY_FLAGS);
 
     // Copy all the transactions into the block
     // FIXME: This should be removed as it is significant overhead.
diff --git a/src/policy/policy.h b/src/policy/policy.h
--- a/src/policy/policy.h
+++ b/src/policy/policy.h
@@ -100,14 +100,6 @@
 static const uint32_t STANDARD_LOCKTIME_VERIFY_FLAGS =
     LOCKTIME_VERIFY_SEQUENCE | LOCKTIME_MEDIAN_TIME_PAST;
 
-/**
- * Used as the flags parameters to check for sigops as if OP_CHECKDATASIG is
- * enabled. Can be removed after OP_CHECKDATASIG is activated as the flag is
- * made standard.
- */
-static const uint32_t STANDARD_CHECKDATASIG_VERIFY_FLAGS =
-    STANDARD_SCRIPT_VERIFY_FLAGS | SCRIPT_ENABLE_CHECKDATASIG;
-
 bool IsStandard(const CScript &scriptPubKey, txnouttype &whichType);
 
 /**
diff --git a/src/policy/policy.cpp b/src/policy/policy.cpp
--- a/src/policy/policy.cpp
+++ b/src/policy/policy.cpp
@@ -141,8 +141,8 @@
             }
 
             CScript subscript(stack.back().begin(), stack.back().end());
-            if (subscript.GetSigOpCount(STANDARD_CHECKDATASIG_VERIFY_FLAGS,
-                                        true) > MAX_P2SH_SIGOPS) {
+            if (subscript.GetSigOpCount(STANDARD_SCRIPT_VERIFY_FLAGS, true) >
+                MAX_P2SH_SIGOPS) {
                 return false;
             }
         }
diff --git a/src/script/standard.h b/src/script/standard.h
--- a/src/script/standard.h
+++ b/src/script/standard.h
@@ -41,7 +41,8 @@
  */
 static const uint32_t MANDATORY_SCRIPT_VERIFY_FLAGS =
     SCRIPT_VERIFY_P2SH | SCRIPT_VERIFY_STRICTENC |
-    SCRIPT_ENABLE_SIGHASH_FORKID | SCRIPT_VERIFY_LOW_S | SCRIPT_VERIFY_NULLFAIL;
+    SCRIPT_ENABLE_SIGHASH_FORKID | SCRIPT_VERIFY_LOW_S |
+    SCRIPT_VERIFY_NULLFAIL | SCRIPT_ENABLE_CHECKDATASIG;
 
 enum txnouttype {
     TX_NONSTANDARD,
diff --git a/src/test/checkdatasig_tests.cpp b/src/test/checkdatasig_tests.cpp
--- a/src/test/checkdatasig_tests.cpp
+++ b/src/test/checkdatasig_tests.cpp
@@ -18,8 +18,9 @@
 
 BOOST_FIXTURE_TEST_SUITE(checkdatasig_tests, BasicTestingSetup)
 
-std::array<uint32_t, 3> flagset{
-    {0, STANDARD_SCRIPT_VERIFY_FLAGS, MANDATORY_SCRIPT_VERIFY_FLAGS}};
+std::array<uint32_t, 3> flagset{{SCRIPT_ENABLE_CHECKDATASIG,
+                                 STANDARD_SCRIPT_VERIFY_FLAGS,
+                                 MANDATORY_SCRIPT_VERIFY_FLAGS}};
 
 const uint8_t vchPrivkey[32] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
                                 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1};
@@ -68,11 +69,11 @@
     for (uint32_t flags : flagset) {
         // Make sure that we get a bad opcode when the activation flag is not
         // passed.
-        CheckError(flags, original_stack, script, SCRIPT_ERR_BAD_OPCODE);
+        CheckError(flags & ~SCRIPT_ENABLE_CHECKDATASIG, original_stack, script,
+                   SCRIPT_ERR_BAD_OPCODE);
 
         // The script execute as expected if the opcodes are activated.
-        CheckPass(flags | SCRIPT_ENABLE_CHECKDATASIG, original_stack, script,
-                  expected);
+        CheckPass(flags, original_stack, script, expected);
     }
 }
 
@@ -81,11 +82,11 @@
     for (uint32_t flags : flagset) {
         // Make sure that we get a bad opcode when the activation flag is not
         // passed.
-        CheckError(flags, original_stack, script, SCRIPT_ERR_BAD_OPCODE);
+        CheckError(flags & ~SCRIPT_ENABLE_CHECKDATASIG, original_stack, script,
+                   SCRIPT_ERR_BAD_OPCODE);
 
         // The script generates the proper error if the opcodes are activated.
-        CheckError(flags | SCRIPT_ENABLE_CHECKDATASIG, original_stack, script,
-                   expected);
+        CheckError(flags, original_stack, script, expected);
     }
 }
 
diff --git a/src/test/script_P2SH_tests.cpp b/src/test/script_P2SH_tests.cpp
--- a/src/test/script_P2SH_tests.cpp
+++ b/src/test/script_P2SH_tests.cpp
@@ -416,7 +416,7 @@
     BOOST_CHECK(::AreInputsStandard(CTransaction(txTo), coins));
     // 22 P2SH sigops for all inputs (1 for vin[0], 6 for vin[3], 15 for vin[4]
     BOOST_CHECK_EQUAL(GetP2SHSigOpCount(CTransaction(txTo), coins,
-                                        STANDARD_CHECKDATASIG_VERIFY_FLAGS),
+                                        STANDARD_SCRIPT_VERIFY_FLAGS),
                       22U);
     // Check that no sigops show up when P2SH is not activated.
     BOOST_CHECK_EQUAL(
@@ -434,7 +434,7 @@
 
     BOOST_CHECK(!::AreInputsStandard(CTransaction(txToNonStd1), coins));
     BOOST_CHECK_EQUAL(GetP2SHSigOpCount(CTransaction(txToNonStd1), coins,
-                                        STANDARD_CHECKDATASIG_VERIFY_FLAGS),
+                                        STANDARD_SCRIPT_VERIFY_FLAGS),
                       16U);
     // Check that no sigops show up when P2SH is not activated.
     BOOST_CHECK_EQUAL(
@@ -453,7 +453,7 @@
 
     BOOST_CHECK(!::AreInputsStandard(CTransaction(txToNonStd2), coins));
     BOOST_CHECK_EQUAL(GetP2SHSigOpCount(CTransaction(txToNonStd2), coins,
-                                        STANDARD_CHECKDATASIG_VERIFY_FLAGS),
+                                        STANDARD_SCRIPT_VERIFY_FLAGS),
                       20U);
     // Check that no sigops show up when P2SH is not activated.
     BOOST_CHECK_EQUAL(
diff --git a/src/test/sigopcount_tests.cpp b/src/test/sigopcount_tests.cpp
--- a/src/test/sigopcount_tests.cpp
+++ b/src/test/sigopcount_tests.cpp
@@ -6,7 +6,7 @@
 #include <consensus/tx_verify.h>
 #include <consensus/validation.h>
 #include <key.h>
-#include <policy/policy.h> // For STANDARD_CHECKDATASIG_VERIFY_FLAGS.
+#include <policy/policy.h> // For STANDARD_SCRIPT_VERIFY_FLAGS.
 #include <pubkey.h>
 #include <script/interpreter.h>
 #include <script/script.h>
@@ -30,20 +30,24 @@
 
 void CheckScriptSigOps(const CScript &script, uint32_t accurate_sigops,
                        uint32_t inaccurate_sigops, uint32_t datasigops) {
+    const uint32_t nodatasigflags =
+        STANDARD_SCRIPT_VERIFY_FLAGS & ~SCRIPT_ENABLE_CHECKDATASIG;
     const uint32_t stdflags = STANDARD_SCRIPT_VERIFY_FLAGS;
-    const uint32_t datasigflags = STANDARD_CHECKDATASIG_VERIFY_FLAGS;
 
-    BOOST_CHECK_EQUAL(script.GetSigOpCount(stdflags, false), inaccurate_sigops);
-    BOOST_CHECK_EQUAL(script.GetSigOpCount(datasigflags, false),
+    BOOST_CHECK_EQUAL(script.GetSigOpCount(nodatasigflags, false),
+                      inaccurate_sigops);
+    BOOST_CHECK_EQUAL(script.GetSigOpCount(stdflags, false),
                       inaccurate_sigops + datasigops);
-    BOOST_CHECK_EQUAL(script.GetSigOpCount(stdflags, true), accurate_sigops);
-    BOOST_CHECK_EQUAL(script.GetSigOpCount(datasigflags, true),
+    BOOST_CHECK_EQUAL(script.GetSigOpCount(nodatasigflags, true),
+                      accurate_sigops);
+    BOOST_CHECK_EQUAL(script.GetSigOpCount(stdflags, true),
                       accurate_sigops + datasigops);
 
     const CScript p2sh = GetScriptForDestination(CScriptID(script));
     const CScript scriptSig = CScript() << OP_0 << Serialize(script);
-    BOOST_CHECK_EQUAL(p2sh.GetSigOpCount(stdflags, scriptSig), accurate_sigops);
-    BOOST_CHECK_EQUAL(p2sh.GetSigOpCount(datasigflags, scriptSig),
+    BOOST_CHECK_EQUAL(p2sh.GetSigOpCount(nodatasigflags, scriptSig),
+                      accurate_sigops);
+    BOOST_CHECK_EQUAL(p2sh.GetSigOpCount(stdflags, scriptSig),
                       accurate_sigops + datasigops);
 
     // Check that GetSigOpCount do not report sigops in the P2SH script when the
@@ -51,8 +55,9 @@
     BOOST_CHECK_EQUAL(p2sh.GetSigOpCount(SCRIPT_VERIFY_NONE, scriptSig), 0U);
 
     // Check that GetSigOpCount report the exact count when not passed a P2SH.
-    BOOST_CHECK_EQUAL(script.GetSigOpCount(stdflags, p2sh), accurate_sigops);
-    BOOST_CHECK_EQUAL(script.GetSigOpCount(datasigflags, p2sh),
+    BOOST_CHECK_EQUAL(script.GetSigOpCount(nodatasigflags, p2sh),
+                      accurate_sigops);
+    BOOST_CHECK_EQUAL(script.GetSigOpCount(stdflags, p2sh),
                       accurate_sigops + datasigops);
     BOOST_CHECK_EQUAL(script.GetSigOpCount(SCRIPT_VERIFY_NONE, p2sh),
                       accurate_sigops);
@@ -87,10 +92,12 @@
     CScript scriptSig2;
     scriptSig2 << OP_1 << ToByteVector(dummy) << ToByteVector(dummy)
                << Serialize(s3);
+    BOOST_CHECK_EQUAL(p2sh.GetSigOpCount((STANDARD_SCRIPT_VERIFY_FLAGS &
+                                          ~SCRIPT_ENABLE_CHECKDATASIG),
+                                         scriptSig2),
+                      3U);
     BOOST_CHECK_EQUAL(
         p2sh.GetSigOpCount(STANDARD_SCRIPT_VERIFY_FLAGS, scriptSig2), 3U);
-    BOOST_CHECK_EQUAL(
-        p2sh.GetSigOpCount(STANDARD_CHECKDATASIG_VERIFY_FLAGS, scriptSig2), 3U);
     BOOST_CHECK_EQUAL(p2sh.GetSigOpCount(SCRIPT_VERIFY_NONE, scriptSig2), 0U);
 
     const CScript s4 = CScript(s1) << OP_IF << OP_CHECKDATASIG << OP_ENDIF;
diff --git a/src/validation.cpp b/src/validation.cpp
--- a/src/validation.cpp
+++ b/src/validation.cpp
@@ -589,8 +589,8 @@
                                  "bad-txns-nonstandard-inputs");
         }
 
-        int64_t nSigOpsCount = GetTransactionSigOpCount(
-            tx, view, STANDARD_CHECKDATASIG_VERIFY_FLAGS);
+        int64_t nSigOpsCount =
+            GetTransactionSigOpCount(tx, view, STANDARD_SCRIPT_VERIFY_FLAGS);
 
         Amount nValueOut = tx.GetValueOut();
         Amount nFees = nValueIn - nValueOut;