diff --git a/csharp/test/Microsoft.ML.OnnxRuntime.Tests/InferenceTest.cs b/csharp/test/Microsoft.ML.OnnxRuntime.Tests/InferenceTest.cs
index 2d870ea2dc..963f314304 100644
--- a/csharp/test/Microsoft.ML.OnnxRuntime.Tests/InferenceTest.cs
+++ b/csharp/test/Microsoft.ML.OnnxRuntime.Tests/InferenceTest.cs
@@ -325,7 +325,10 @@ namespace Microsoft.ML.OnnxRuntime.Tests
                 { "fp16_shufflenet", "16-bit float not supported type in C#." },
                 { "fp16_tiny_yolov2", "16-bit float not supported type in C#." },
                 { "BERT_Squad", "Could not find an implementation for the node bert / embeddings / one_hot:OneHot(9)" },
-                { "mlperf_ssd_mobilenet_300", "Could not find file output_0.pb" }
+                { "mlperf_ssd_mobilenet_300", "Could not find file output_0.pb" },
+                { "tf_resnet_v1_50", "result mismatch when Conv BN Fusion is applied" },
+                { "tf_resnet_v1_101", "result mismatch when Conv BN Fusion is applied" },
+                { "tf_resnet_v1_152", "result mismatch when Conv BN Fusion is applied" }
             };
 
             // The following models fails on nocontribops win CI
diff --git a/onnxruntime/core/optimizer/graph_transformer_utils.cc b/onnxruntime/core/optimizer/graph_transformer_utils.cc
index ef9dbe8602..c3b6ffb341 100644
--- a/onnxruntime/core/optimizer/graph_transformer_utils.cc
+++ b/onnxruntime/core/optimizer/graph_transformer_utils.cc
@@ -41,14 +41,15 @@ std::vector<std::unique_ptr<RewriteRule>> GenerateRewriteRules(TransformerLevel
       rules.push_back(onnxruntime::make_unique<EliminateDropout>());
       rules.push_back(onnxruntime::make_unique<FuseReluClip>());
       rules.push_back(onnxruntime::make_unique<ShapeToInitializer>());
-      break;
-
-    case TransformerLevel::Level2:
       rules.push_back(onnxruntime::make_unique<ConvAddFusion>());
       rules.push_back(onnxruntime::make_unique<ConvMulFusion>());
       rules.push_back(onnxruntime::make_unique<ConvBNFusion>());
       break;
 
+    case TransformerLevel::Level2:
+      // No level2 rules available today
+      break;
+
     case TransformerLevel::Level3:
       break;
 
@@ -99,6 +100,7 @@ std::vector<std::unique_ptr<GraphTransformer>> GenerateTransformers(TransformerL
       std::unordered_set<std::string> l1_execution_providers = {};
 
       transformers.emplace_back(onnxruntime::make_unique<ConstantFolding>(l1_execution_providers));
+      transformers.emplace_back(onnxruntime::make_unique<MatMulAddFusion>(l1_execution_providers));
       transformers.emplace_back(onnxruntime::make_unique<FreeDimensionOverrideTransformer>(free_dimension_overrides));
 
       rule_transformer = GenerateRuleBasedGraphTransformer(level, transformers_and_rules_to_enable, l1_execution_providers);
@@ -113,7 +115,6 @@ std::vector<std::unique_ptr<GraphTransformer>> GenerateTransformers(TransformerL
       // create standalone transformers
 #ifndef DISABLE_CONTRIB_OPS
       transformers.emplace_back(onnxruntime::make_unique<GemmActivationFusion>(l2_execution_providers));
-      transformers.emplace_back(onnxruntime::make_unique<MatMulAddFusion>(l2_execution_providers));
       transformers.emplace_back(onnxruntime::make_unique<ConvActivationFusion>(l2_execution_providers));
       transformers.emplace_back(onnxruntime::make_unique<GeluFusion>(l2_execution_providers));
 #endif
diff --git a/onnxruntime/test/onnx/main.cc b/onnxruntime/test/onnx/main.cc
index f19595190f..b72efb6c4c 100644
--- a/onnxruntime/test/onnx/main.cc
+++ b/onnxruntime/test/onnx/main.cc
@@ -421,6 +421,9 @@ int real_main(int argc, char* argv[], Ort::Env& env) {
       {"shrink", "test case is wrong", {"onnx141"}},
       {"maxpool_with_argmax_2d_precomputed_strides", "ShapeInferenceError"},
       {"tf_inception_v2", "result mismatch"},
+      {"tf_resnet_v1_50", "result mismatch when Conv BN Fusion is applied"},
+      {"tf_resnet_v1_101", "result mismatch when Conv BN Fusion is applied"},
+      {"tf_resnet_v1_152", "result mismatch when Conv BN Fusion is applied"},
       {"mxnet_arcface", "Model is an invalid ONNX model"},
       {"unique_not_sorted_without_axis", "Expected data for 'Y' is incorrect and in sorted order."},
       {"cumsum_1d_reverse_exclusive", "only failing linux GPU CI. Likely build error."},
diff --git a/onnxruntime/test/optimizer/graph_transform_test.cc b/onnxruntime/test/optimizer/graph_transform_test.cc
index c666167039..f0e71382fd 100644
--- a/onnxruntime/test/optimizer/graph_transform_test.cc
+++ b/onnxruntime/test/optimizer/graph_transform_test.cc
@@ -246,11 +246,11 @@ TEST(GraphTransformationTests, FuseConvBNNoBias) {
   Graph& graph = p_model->MainGraph();
 
   onnxruntime::GraphTransformerManager graph_transformation_mgr{5};
-  auto rule_transformer_L2 = onnxruntime::make_unique<RuleBasedGraphTransformer>("RuleTransformerL2");
-  rule_transformer_L2->Register(onnxruntime::make_unique<ConvBNFusion>());
-  graph_transformation_mgr.Register(std::move(rule_transformer_L2), TransformerLevel::Level2);
+  auto rule_transformer_L1 = onnxruntime::make_unique<RuleBasedGraphTransformer>("RuleTransformerL1");
+  rule_transformer_L1->Register(onnxruntime::make_unique<ConvBNFusion>());
+  graph_transformation_mgr.Register(std::move(rule_transformer_L1), TransformerLevel::Level1);
 
-  ASSERT_TRUE(graph_transformation_mgr.ApplyTransformers(graph, TransformerLevel::Level2).IsOK());
+  ASSERT_TRUE(graph_transformation_mgr.ApplyTransformers(graph, TransformerLevel::Level1).IsOK());
 
   std::map<std::string, int> op_to_count = CountOpsInGraph(graph);
   ASSERT_TRUE(op_to_count["BatchNormalization"] == 0);
@@ -269,16 +269,12 @@ TEST(GraphTransformationTests, FuseConvBNMulAddUnsqueeze) {
     onnxruntime::GraphTransformerManager graph_transformation_mgr{5};
     auto rule_transformer_L1 = onnxruntime::make_unique<RuleBasedGraphTransformer>("RuleTransformer1");
     rule_transformer_L1->Register(onnxruntime::make_unique<UnsqueezeElimination>());
+    rule_transformer_L1->Register(onnxruntime::make_unique<ConvAddFusion>());
+    rule_transformer_L1->Register(onnxruntime::make_unique<ConvBNFusion>());
+    rule_transformer_L1->Register(onnxruntime::make_unique<ConvMulFusion>());
     graph_transformation_mgr.Register(std::move(rule_transformer_L1), TransformerLevel::Level1);
 
-    auto rule_transformer_L2 = onnxruntime::make_unique<RuleBasedGraphTransformer>("RuleTransformerL2");
-    rule_transformer_L2->Register(onnxruntime::make_unique<ConvAddFusion>());
-    rule_transformer_L2->Register(onnxruntime::make_unique<ConvBNFusion>());
-    rule_transformer_L2->Register(onnxruntime::make_unique<ConvMulFusion>());
-    graph_transformation_mgr.Register(std::move(rule_transformer_L2), TransformerLevel::Level2);
-
     ASSERT_TRUE(graph_transformation_mgr.ApplyTransformers(graph, TransformerLevel::Level1).IsOK());
-    ASSERT_TRUE(graph_transformation_mgr.ApplyTransformers(graph, TransformerLevel::Level2).IsOK());
 
     std::map<std::string, int> op_to_count = CountOpsInGraph(graph);
     ASSERT_TRUE(op_to_count["BatchNormalization"] == 0);
@@ -364,14 +360,10 @@ TEST(GraphTransformationTests, FuseConvMulNoBias) {
   onnxruntime::GraphTransformerManager graph_transformation_mgr{5};
   auto rule_transformer_L1 = onnxruntime::make_unique<RuleBasedGraphTransformer>("RuleTransformer1");
   rule_transformer_L1->Register(onnxruntime::make_unique<UnsqueezeElimination>());
+  rule_transformer_L1->Register(onnxruntime::make_unique<ConvMulFusion>());
   graph_transformation_mgr.Register(std::move(rule_transformer_L1), TransformerLevel::Level1);
 
-  auto rule_transformer_L2 = onnxruntime::make_unique<RuleBasedGraphTransformer>("RuleTransformerL2");
-  rule_transformer_L2->Register(onnxruntime::make_unique<ConvMulFusion>());
-  graph_transformation_mgr.Register(std::move(rule_transformer_L2), TransformerLevel::Level2);
-
   ASSERT_TRUE(graph_transformation_mgr.ApplyTransformers(graph, TransformerLevel::Level1).IsOK());
-  ASSERT_TRUE(graph_transformation_mgr.ApplyTransformers(graph, TransformerLevel::Level2).IsOK());
 
   std::map<std::string, int> op_to_count = CountOpsInGraph(graph);
   ASSERT_TRUE(op_to_count["Mul"] == 0);
@@ -388,14 +380,10 @@ TEST(GraphTransformationTests, FuseConvAddNoBias) {
   onnxruntime::GraphTransformerManager graph_transformation_mgr{5};
   auto rule_transformer_L1 = onnxruntime::make_unique<RuleBasedGraphTransformer>("RuleTransformer1");
   rule_transformer_L1->Register(onnxruntime::make_unique<UnsqueezeElimination>());
+  rule_transformer_L1->Register(onnxruntime::make_unique<ConvAddFusion>());
   graph_transformation_mgr.Register(std::move(rule_transformer_L1), TransformerLevel::Level1);
 
-  auto rule_transformer_L2 = onnxruntime::make_unique<RuleBasedGraphTransformer>("RuleTransformerL2");
-  rule_transformer_L2->Register(onnxruntime::make_unique<ConvAddFusion>());
-  graph_transformation_mgr.Register(std::move(rule_transformer_L2), TransformerLevel::Level2);
-
   ASSERT_TRUE(graph_transformation_mgr.ApplyTransformers(graph, TransformerLevel::Level1).IsOK());
-  ASSERT_TRUE(graph_transformation_mgr.ApplyTransformers(graph, TransformerLevel::Level2).IsOK());
 
   std::map<std::string, int> op_to_count = CountOpsInGraph(graph);
   ASSERT_TRUE(op_to_count["Add"] == 0);
@@ -414,14 +402,10 @@ TEST(GraphTransformationTests, NegativeFuseConvAddNoBias) {
   onnxruntime::GraphTransformerManager graph_transformation_mgr{5};
   auto rule_transformer_L1 = onnxruntime::make_unique<RuleBasedGraphTransformer>("RuleTransformer1");
   rule_transformer_L1->Register(onnxruntime::make_unique<UnsqueezeElimination>());
+  rule_transformer_L1->Register(onnxruntime::make_unique<ConvAddFusion>());
   graph_transformation_mgr.Register(std::move(rule_transformer_L1), TransformerLevel::Level1);
 
-  auto rule_transformer_L2 = onnxruntime::make_unique<RuleBasedGraphTransformer>("RuleTransformerL2");
-  rule_transformer_L2->Register(onnxruntime::make_unique<ConvAddFusion>());
-  graph_transformation_mgr.Register(std::move(rule_transformer_L2), TransformerLevel::Level2);
-
   ASSERT_TRUE(graph_transformation_mgr.ApplyTransformers(graph, TransformerLevel::Level1).IsOK());
-  ASSERT_TRUE(graph_transformation_mgr.ApplyTransformers(graph, TransformerLevel::Level2).IsOK());
 
   // Nodes are not fused because the weights to conv/add are not constants (they appear in the graph inputs).
   // Unsqueeze is also not eliminated as the initializer that is its input is also not constant
@@ -438,12 +422,12 @@ TEST(GraphTransformationTests, FuseConvAddMul3D) {
   Graph& graph = p_model->MainGraph();
 
   onnxruntime::GraphTransformerManager graph_transformation_mgr{5};
-  auto rule_transformer_L2 = onnxruntime::make_unique<RuleBasedGraphTransformer>("RuleTransformerL2");
-  rule_transformer_L2->Register(onnxruntime::make_unique<ConvAddFusion>());
-  rule_transformer_L2->Register(onnxruntime::make_unique<ConvMulFusion>());
-  graph_transformation_mgr.Register(std::move(rule_transformer_L2), TransformerLevel::Level2);
+  auto rule_transformer_L1 = onnxruntime::make_unique<RuleBasedGraphTransformer>("RuleTransformerL1");
+  rule_transformer_L1->Register(onnxruntime::make_unique<ConvAddFusion>());
+  rule_transformer_L1->Register(onnxruntime::make_unique<ConvMulFusion>());
+  graph_transformation_mgr.Register(std::move(rule_transformer_L1), TransformerLevel::Level1);
 
-  ASSERT_TRUE(graph_transformation_mgr.ApplyTransformers(graph, TransformerLevel::Level2).IsOK());
+  ASSERT_TRUE(graph_transformation_mgr.ApplyTransformers(graph, TransformerLevel::Level1).IsOK());
 
   std::map<std::string, int> op_to_count = CountOpsInGraph(graph);
   ASSERT_TRUE(op_to_count["Add"] == 0);
@@ -458,12 +442,12 @@ TEST(GraphTransformationTests, FuseConvAddMul3D_2) {
   Graph& graph = p_model->MainGraph();
 
   onnxruntime::GraphTransformerManager graph_transformation_mgr{5};
-  auto rule_transformer_L2 = onnxruntime::make_unique<RuleBasedGraphTransformer>("RuleTransformerL2");
-  rule_transformer_L2->Register(onnxruntime::make_unique<ConvAddFusion>());
-  rule_transformer_L2->Register(onnxruntime::make_unique<ConvMulFusion>());
-  graph_transformation_mgr.Register(std::move(rule_transformer_L2), TransformerLevel::Level2);
+  auto rule_transformer_L1 = onnxruntime::make_unique<RuleBasedGraphTransformer>("RuleTransformerL1");
+  rule_transformer_L1->Register(onnxruntime::make_unique<ConvAddFusion>());
+  rule_transformer_L1->Register(onnxruntime::make_unique<ConvMulFusion>());
+  graph_transformation_mgr.Register(std::move(rule_transformer_L1), TransformerLevel::Level1);
 
-  ASSERT_TRUE(graph_transformation_mgr.ApplyTransformers(graph, TransformerLevel::Level2).IsOK());
+  ASSERT_TRUE(graph_transformation_mgr.ApplyTransformers(graph, TransformerLevel::Level1).IsOK());
 
   std::map<std::string, int> op_to_count = CountOpsInGraph(graph);
   ASSERT_TRUE(op_to_count["Add"] == 0);
@@ -478,8 +462,8 @@ TEST(GraphTransformationTests, MatMulAddFusion_two_input) {
   Graph& graph = p_model->MainGraph();
 
   onnxruntime::GraphTransformerManager graph_transformation_mgr{5};
-  graph_transformation_mgr.Register(onnxruntime::make_unique<MatMulAddFusion>(), TransformerLevel::Level2);
-  ASSERT_TRUE(graph_transformation_mgr.ApplyTransformers(graph, TransformerLevel::Level2).IsOK());
+  graph_transformation_mgr.Register(onnxruntime::make_unique<MatMulAddFusion>(), TransformerLevel::Level1);
+  ASSERT_TRUE(graph_transformation_mgr.ApplyTransformers(graph, TransformerLevel::Level1).IsOK());
 
   std::map<std::string, int> op_to_count = CountOpsInGraph(graph);
   ASSERT_TRUE(op_to_count["MatMul"] == 0);
@@ -495,8 +479,8 @@ TEST(GraphTransformationTests, MatMulAddFusion_three_input) {
   Graph& graph = p_model->MainGraph();
 
   onnxruntime::GraphTransformerManager graph_transformation_mgr{5};
-  graph_transformation_mgr.Register(onnxruntime::make_unique<MatMulAddFusion>(), TransformerLevel::Level2);
-  ASSERT_TRUE(graph_transformation_mgr.ApplyTransformers(graph, TransformerLevel::Level2).IsOK());
+  graph_transformation_mgr.Register(onnxruntime::make_unique<MatMulAddFusion>(), TransformerLevel::Level1);
+  ASSERT_TRUE(graph_transformation_mgr.ApplyTransformers(graph, TransformerLevel::Level1).IsOK());
 
   std::map<std::string, int> op_to_count = CountOpsInGraph(graph);
   ASSERT_TRUE(op_to_count["MatMul"] == 0);
@@ -532,11 +516,11 @@ TEST(GraphTransformationTests, FuseConvBnAddMulFloat16) {
   std::shared_ptr<Model> p_model;
   ASSERT_TRUE(Model::Load(model_uri, p_model).IsOK());
 
-  auto rule_transformer_L2 = onnxruntime::make_unique<RuleBasedGraphTransformer>("RuleTransformerL2");
-  rule_transformer_L2->Register(onnxruntime::make_unique<ConvAddFusion>());
-  rule_transformer_L2->Register(onnxruntime::make_unique<ConvBNFusion>());
-  rule_transformer_L2->Register(onnxruntime::make_unique<ConvMulFusion>());
-  session_object.RegisterGraphTransformer(std::move(rule_transformer_L2), TransformerLevel::Level2);
+  auto rule_transformer_L1 = onnxruntime::make_unique<RuleBasedGraphTransformer>("RuleTransformerL1");
+  rule_transformer_L1->Register(onnxruntime::make_unique<ConvAddFusion>());
+  rule_transformer_L1->Register(onnxruntime::make_unique<ConvBNFusion>());
+  rule_transformer_L1->Register(onnxruntime::make_unique<ConvMulFusion>());
+  session_object.RegisterGraphTransformer(std::move(rule_transformer_L1), TransformerLevel::Level1);
 
   ASSERT_TRUE(session_object.Initialize().IsOK());
 
diff --git a/onnxruntime/test/optimizer/graph_transform_utils_test.cc b/onnxruntime/test/optimizer/graph_transform_utils_test.cc
index f47e0eb49f..190a289807 100644
--- a/onnxruntime/test/optimizer/graph_transform_utils_test.cc
+++ b/onnxruntime/test/optimizer/graph_transform_utils_test.cc
@@ -38,8 +38,8 @@ TEST(GraphTransformerUtilsTests, TestGenerateGraphTransformers) {
   // custom list of rules and transformers
   std::string l1_rule1 = "EliminateIdentity";
   std::string l1_transformer = "ConstantFolding";
-  std::string l2_rule1 = "ConvBNFusion";
-  std::vector<std::string> custom_list = {l1_rule1, l1_transformer, l2_rule1};
+  std::string l2_transformer = "ConvActivationFusion";
+  std::vector<std::string> custom_list = {l1_rule1, l1_transformer, l2_transformer};
 
   auto transformers = optimizer_utils::GenerateTransformers(TransformerLevel::Level1, {}, custom_list);
   ASSERT_TRUE(transformers.size() == 2);
@@ -51,11 +51,13 @@ TEST(GraphTransformerUtilsTests, TestGenerateGraphTransformers) {
     }
   }
   ASSERT_TRUE(rule_transformer && rule_transformer->RulesCount() == 1);
-
+  
   transformers = optimizer_utils::GenerateTransformers(TransformerLevel::Level2, {}, custom_list);
+#ifndef DISABLE_CONTRIB_OPS
   ASSERT_TRUE(transformers.size() == 1);
-  rule_transformer = dynamic_cast<RuleBasedGraphTransformer*>(transformers[0].get());
-  ASSERT_TRUE(rule_transformer->RulesCount() == 1);
+#else
+  ASSERT_TRUE(transformers.size() == 0);
+#endif
 }
 
 }  // namespace test