diff --git a/src/armnnSerializer/ArmnnSchema.fbs b/src/armnnSerializer/ArmnnSchema.fbs
index 84149bd..76a1c12 100644
--- a/src/armnnSerializer/ArmnnSchema.fbs
+++ b/src/armnnSerializer/ArmnnSchema.fbs
@@ -184,6 +184,7 @@
     GatherNd = 67,
     BatchMatMul = 68,
     ElementwiseBinary = 69,
+    ReverseV2 = 70,
 }
 
 // Base layer table to be used as part of other layers
@@ -979,6 +980,15 @@
     halfPixelCenters:bool;
 }
 
+table ReverseV2Layer {
+    base:LayerBase;
+    descriptor:ReverseV2Descriptor;
+}
+
+table ReverseV2Descriptor {
+    axis:[int];
+}
+
 table StackLayer {
     base:LayerBase;
     descriptor:StackDescriptor;
@@ -1117,6 +1127,7 @@
     GatherNdLayer,
     BatchMatMulLayer,
     ElementwiseBinaryLayer,
+    ReverseV2Layer,
 }
 
 table AnyLayer {
diff --git a/src/armnnSerializer/Serializer.cpp b/src/armnnSerializer/Serializer.cpp
index 5a095d9..cf098eb 100644
--- a/src/armnnSerializer/Serializer.cpp
+++ b/src/armnnSerializer/Serializer.cpp
@@ -1035,6 +1035,25 @@
     CreateAnyLayer(flatBufferLayer.o, serializer::Layer::Layer_ResizeLayer);
 }
 
+void SerializerStrategy::SerializeReverseV2Layer(const armnn::IConnectableLayer* layer,
+                                              const armnn::ReverseV2Descriptor& reverseV2Descriptor,
+                                              const char* name)
+{
+    IgnoreUnused(name);
+
+    auto flatBufferBaseLayer = CreateLayerBase(layer, serializer::LayerType::LayerType_ReverseV2);
+
+    auto flatBufferDescriptor =
+        CreateReverseV2Descriptor(m_flatBufferBuilder,
+                                  m_flatBufferBuilder.CreateVector(reverseV2Descriptor.m_Axis));
+
+    auto flatBufferLayer = serializer::CreateReverseV2Layer(m_flatBufferBuilder,
+                                                            flatBufferBaseLayer,
+                                                            flatBufferDescriptor);
+
+    CreateAnyLayer(flatBufferLayer.o, serializer::Layer::Layer_ReverseV2Layer);
+}
+
 void SerializerStrategy::SerializeSliceLayer(const armnn::IConnectableLayer* layer,
                                         const armnn::SliceDescriptor& sliceDescriptor,
                                         const char* name)
@@ -2332,6 +2351,13 @@
             SerializeResizeLayer(layer, layerDescriptor, name);
             break;
         }
+        case armnn::LayerType::ReverseV2:
+        {
+            const armnn::ReverseV2Descriptor& layerDescriptor =
+                    static_cast<const armnn::ReverseV2Descriptor&>(descriptor);
+            SerializeReverseV2Layer(layer, layerDescriptor, name);
+            break;
+        }
         case armnn::LayerType::Shape:
         {
             SerializeShapeLayer(layer, name);
diff --git a/src/armnnSerializer/Serializer.hpp b/src/armnnSerializer/Serializer.hpp
index 4d5e806..eb72475 100644
--- a/src/armnnSerializer/Serializer.hpp
+++ b/src/armnnSerializer/Serializer.hpp
@@ -289,6 +289,10 @@
                               const armnn::ResizeDescriptor& resizeDescriptor,
                               const char* name = nullptr);
 
+    void SerializeReverseV2Layer(const armnn::IConnectableLayer* layer,
+                                 const armnn::ReverseV2Descriptor& reverseV2Descriptor,
+                                 const char* name = nullptr);
+
     void SerializeSliceLayer(const armnn::IConnectableLayer* layer,
                              const armnn::SliceDescriptor& sliceDescriptor,
                              const char* name = nullptr);
diff --git a/src/armnnSerializer/test/SerializerTests.cpp b/src/armnnSerializer/test/SerializerTests.cpp
index bd8a76a..7a988ee 100644
--- a/src/armnnSerializer/test/SerializerTests.cpp
+++ b/src/armnnSerializer/test/SerializerTests.cpp
@@ -2453,6 +2453,33 @@
     deserializedNetwork->ExecuteStrategy(verifier);
 }
 
+TEST_CASE("SerializeReverseV2")
+{
+    const std::string layerName("reverseV2");
+    const armnn::TensorInfo inputInfo  = armnn::TensorInfo({2, 3, 4}, armnn::DataType::Float32);
+    const armnn::TensorInfo outputInfo = armnn::TensorInfo({2, 3, 4}, armnn::DataType::Float32);
+
+    armnn::ReverseV2Descriptor desc;
+    desc.m_Axis = {1, 0, 2};
+
+    armnn::INetworkPtr network = armnn::INetwork::Create();
+    armnn::IConnectableLayer* const inputLayer = network->AddInputLayer(0);
+    armnn::IConnectableLayer* const reverseV2Layer = network->AddReverseV2Layer(desc, layerName.c_str());
+    armnn::IConnectableLayer* const outputLayer = network->AddOutputLayer(0);
+
+    inputLayer->GetOutputSlot(0).Connect(reverseV2Layer->GetInputSlot(0));
+    reverseV2Layer->GetOutputSlot(0).Connect(outputLayer->GetInputSlot(0));
+
+    inputLayer->GetOutputSlot(0).SetTensorInfo(inputInfo);
+    reverseV2Layer->GetOutputSlot(0).SetTensorInfo(outputInfo);
+
+    armnn::INetworkPtr deserializedNetwork = DeserializeNetwork(SerializeNetwork(*network));
+    CHECK(deserializedNetwork);
+
+    LayerVerifierBaseWithDescriptor<armnn::ReverseV2Descriptor> verifier(layerName, {inputInfo}, {outputInfo}, desc);
+    deserializedNetwork->ExecuteStrategy(verifier);
+}
+
 TEST_CASE("SerializeShape")
 {
     const std::string layerName("shape");
@@ -2981,4 +3008,4 @@
     deserializedNetwork->ExecuteStrategy(verifier);
 }
 
-}
\ No newline at end of file
+}