diff --git a/src/test/op_reversebytes_tests.cpp b/src/test/op_reversebytes_tests.cpp
--- a/src/test/op_reversebytes_tests.cpp
+++ b/src/test/op_reversebytes_tests.cpp
@@ -2,6 +2,7 @@
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
+#include <policy/policy.h>
 #include <script/interpreter.h>
 #include <script/script.h>
 
@@ -13,6 +14,9 @@
 typedef std::vector<uint8_t> valtype;
 typedef std::vector<valtype> stacktype;
 
+static std::set<uint32_t> curated_datasizes({0, 1, 2, 10, 16, 32, 50, 128, 300,
+                                             400, 512, 519, 520});
+
 BOOST_FIXTURE_TEST_SUITE(op_reversebytes_tests, BasicTestingSetup)
 
 struct ReverseTestCase {
@@ -74,83 +78,149 @@
 }
 
 /**
- * Verifies a given reverse test case.
- * Checks both if <item> OP_REVERSEBYTES results in <reversed_item> and
- * whether double-reversing <item> is a no-op.
+ * Verifies the different combinations of a given test case.
+ * Checks if
+ * - <item> OP_REVERSEBYTES results in <reversed_item>,
+ * - <reversed_item> OP_REVERSEBYTES results in <item>,
+ * - <item> {OP_REVERSEBYTES} x 2 results in <item> and
+ * - <reversed_item> {OP_REVERSEBYTES} x 2 results in <reversed_item>.
  */
-static void CheckPassReverse(const uint32_t flags,
-                             const ReverseTestCase &reverse_case) {
-    CheckPassIfEnabled(flags, {reverse_case.item}, CScript() << OP_REVERSEBYTES,
-                       {reverse_case.reversed_item});
-    CheckPassIfEnabled(flags, {reverse_case.item},
-                       CScript() << OP_DUP << OP_REVERSEBYTES << OP_REVERSEBYTES
-                                 << OP_EQUALVERIFY,
-                       {});
+static void CheckTestCaseCombos(const uint32_t flags,
+                                const ReverseTestCase &test_case) {
+    CheckPassIfEnabled(flags, {test_case.item}, CScript() << OP_REVERSEBYTES,
+                       {test_case.reversed_item});
+    CheckPassIfEnabled(flags, {test_case.reversed_item},
+                       CScript() << OP_REVERSEBYTES, {test_case.item});
+    CheckPassIfEnabled(flags, {test_case.item},
+                       CScript() << OP_REVERSEBYTES << OP_REVERSEBYTES,
+                       {test_case.item});
+    CheckPassIfEnabled(flags, {test_case.reversed_item},
+                       CScript() << OP_REVERSEBYTES << OP_REVERSEBYTES,
+                       {test_case.reversed_item});
 }
 
-BOOST_AUTO_TEST_CASE(op_reversebytes_tests) {
+/**
+ * Runs a given test on random flags.
+ */
+static void RunTestWithRandomFlags(const std::function<void(uint32_t)> &test) {
     MMIXLinearCongruentialGenerator lcg;
-    // Manual tests.
-    std::vector<ReverseTestCase> test_cases({
-        {{}, {}},
-        {{99}, {99}},
-        {{0xde, 0xad}, {0xad, 0xde}},
-        {{0xde, 0xad, 0xa1}, {0xa1, 0xad, 0xde}},
-        {{0xde, 0xad, 0xbe, 0xef}, {0xef, 0xbe, 0xad, 0xde}},
-        {{0x12, 0x34, 0x56}, {0x56, 0x34, 0x12}},
-    });
+    for (int i = 0; i < 2048; i++) {
+        // Generate random flags.
+        uint32_t flags = lcg.next();
+        test(flags);
+    }
+}
 
-    // Palindrome tests, they are their own reverse.
-    std::vector<valtype> palindromes;
-    palindromes.reserve(MAX_SCRIPT_ELEMENT_SIZE);
+/**
+ * Runs a given test on a curated set of flags.
+ */
+static void RunTestWithCuratedFlags(const std::function<void(uint32_t)> &test) {
+    // Test cases for a few interesting script flag combinations.
+    test(0);
+    test(STANDARD_SCRIPT_VERIFY_FLAGS);
+    test(MANDATORY_SCRIPT_VERIFY_FLAGS);
+    for (uint32_t flagindex = 0; flagindex < 32; ++flagindex) {
+        uint32_t flags = 1 << flagindex;
+        test(flags);
+    }
+}
 
-    // Generated tests:
-    // - for iota(n) mod 256, n = 0,..,520.
-    // - for random bitstrings, n = 0,..,520.
-    // - for palindromes 0,..,n,..,0.
+/**
+ * Runs make_test_case on all possible stack item sizes and checks the resulting
+ * test case.
+ */
+static void CheckForAllDataSizes(
+    const std::function<ReverseTestCase(uint32_t)> make_test_case) {
     for (size_t datasize = 0; datasize <= MAX_SCRIPT_ELEMENT_SIZE; ++datasize) {
-        valtype iota_data, random_data, palindrome;
-        iota_data.reserve(datasize);
-        random_data.reserve(datasize);
-        palindrome.reserve(datasize);
-        for (size_t item = 0; item < datasize; ++item) {
-            iota_data.emplace_back(item % 256);
-            random_data.emplace_back(lcg.next() % 256);
-            palindrome.emplace_back(
-                (item < (datasize + 1) / 2 ? item : datasize - item - 1) % 256);
+        const ReverseTestCase test_case = make_test_case(datasize);
+        const std::function<void(uint32_t)> f = [&test_case](uint32_t flags) {
+            return CheckTestCaseCombos(flags, test_case);
+        };
+        RunTestWithCuratedFlags(f);
+        if (curated_datasizes.find(datasize) != curated_datasizes.end()) {
+            RunTestWithRandomFlags(f);
         }
-        test_cases.push_back(
-            {iota_data, {iota_data.rbegin(), iota_data.rend()}});
-        test_cases.push_back(
-            {random_data, {random_data.rbegin(), random_data.rend()}});
-        palindromes.push_back(palindrome);
     }
+}
 
-    for (int i = 0; i < 4096; i++) {
-        // Generate random flags.
-        uint32_t flags = lcg.next();
+BOOST_AUTO_TEST_CASE(op_reversebytes_manual) {
+    // Test a few simple manual cases.
+    std::function<void(ReverseTestCase)> test = [](ReverseTestCase test_case) {
+        RunTestWithRandomFlags([&test_case](uint32_t flags) {
+            CheckTestCaseCombos(flags, test_case);
+        });
+    };
+    test({{}, {}});
+    test({{99}, {99}});
+    test({{0xde, 0xad}, {0xad, 0xde}});
+    test({{0xde, 0xad, 0xa1}, {0xa1, 0xad, 0xde}});
+    test({{0xde, 0xad, 0xbe, 0xef}, {0xef, 0xbe, 0xad, 0xde}});
+    test({{0x12, 0x34, 0x56}, {0x56, 0x34, 0x12}});
+}
 
-        // Empty stack.
-        CheckErrorIfEnabled(flags, {}, CScript() << OP_REVERSEBYTES,
-                            ScriptError::INVALID_STACK_OPERATION);
+BOOST_AUTO_TEST_CASE(op_reversebytes_iota) {
+    // Test byte strings 0..n (mod 256).
+    CheckForAllDataSizes([](uint32_t datasize) {
+        valtype iota_data;
+        iota_data.reserve(datasize);
+        for (size_t item = 0; item < datasize; ++item) {
+            iota_data.emplace_back(item % 256);
+        }
+        return ReverseTestCase{iota_data,
+                               {iota_data.rbegin(), iota_data.rend()}};
+    });
+}
 
-        for (const ReverseTestCase &test_case : test_cases) {
-            CheckPassReverse(flags, test_case);
+BOOST_AUTO_TEST_CASE(op_reversebytes_random) {
+    // Test random byte strings.
+    MMIXLinearCongruentialGenerator lcg;
+    CheckForAllDataSizes([&lcg](uint32_t datasize) {
+        valtype random_data;
+        random_data.reserve(datasize);
+        for (size_t item = 0; item < datasize; ++item) {
+            random_data.emplace_back(lcg.next() % 256);
         }
+        return ReverseTestCase{random_data,
+                               {random_data.rbegin(), random_data.rend()}};
+    });
+}
 
-        for (const valtype &palindrome : palindromes) {
-            // Verify palindrome.
-            CheckPassIfEnabled(
-                flags, {palindrome},
-                CScript() << OP_DUP << OP_REVERSEBYTES << OP_EQUALVERIFY, {});
+BOOST_AUTO_TEST_CASE(op_reversebytes_palindrome) {
+    // Test palindromes.
+    for (size_t datasize = 0; datasize <= MAX_SCRIPT_ELEMENT_SIZE; ++datasize) {
+        valtype palindrome;
+        palindrome.reserve(datasize);
+        for (size_t item = 0; item < datasize; ++item) {
+            palindrome.emplace_back(
+                (item < (datasize + 1) / 2 ? item : datasize - item - 1) % 256);
+        }
+        const std::function<void(uint32_t)> f = [&palindrome](uint32_t flags) {
+            CheckPassIfEnabled(flags, {palindrome},
+                               CScript() << OP_REVERSEBYTES, {palindrome});
+        };
+        RunTestWithCuratedFlags(f);
+        if (curated_datasizes.find(datasize) != curated_datasizes.end()) {
+            RunTestWithRandomFlags(f);
         }
+    }
+}
 
+BOOST_AUTO_TEST_CASE(op_reversebytes_non_palindrome) {
+    RunTestWithRandomFlags([](uint32_t flags) {
         // Verify non-palindrome fails.
         CheckErrorIfEnabled(flags, {{0x01, 0x02, 0x03, 0x02, 0x02}},
                             CScript()
                                 << OP_DUP << OP_REVERSEBYTES << OP_EQUALVERIFY,
                             ScriptError::EQUALVERIFY);
-    }
+    });
+}
+
+BOOST_AUTO_TEST_CASE(op_reversebytes_empty_stack) {
+    RunTestWithRandomFlags([](uint32_t flags) {
+        // Empty stack.
+        CheckErrorIfEnabled(flags, {}, CScript() << OP_REVERSEBYTES,
+                            ScriptError::INVALID_STACK_OPERATION);
+    });
 }
 
 BOOST_AUTO_TEST_SUITE_END()