diff --git a/src/core/coap/coap_message.cpp b/src/core/coap/coap_message.cpp
index e3cc6486c..b8df47d5a 100644
--- a/src/core/coap/coap_message.cpp
+++ b/src/core/coap/coap_message.cpp
@@ -264,7 +264,7 @@ otError Message::ParseHeader(void)
 
     VerifyOrExit(iterator.mNextOptionOffset > 0, error = OT_ERROR_PARSE);
     GetHelpData().mHeaderLength = iterator.mNextOptionOffset - GetHelpData().mHeaderOffset;
-    IgnoreError(MoveOffset(GetHelpData().mHeaderLength));
+    MoveOffset(GetHelpData().mHeaderLength);
 
 exit:
     return error;
diff --git a/src/core/common/message.cpp b/src/core/common/message.cpp
index 8ab66c534..1ba41e982 100644
--- a/src/core/common/message.cpp
+++ b/src/core/common/message.cpp
@@ -308,18 +308,11 @@ uint8_t Message::GetBufferCount(void) const
     return rval;
 }
 
-otError Message::MoveOffset(int aDelta)
+void Message::MoveOffset(int aDelta)
 {
-    otError error = OT_ERROR_NONE;
-
     OT_ASSERT(GetOffset() + aDelta <= GetLength());
-    VerifyOrExit(GetOffset() + aDelta <= GetLength(), error = OT_ERROR_INVALID_ARGS);
-
     mBuffer.mHead.mInfo.mOffset += static_cast<int16_t>(aDelta);
     OT_ASSERT(mBuffer.mHead.mInfo.mOffset <= GetLength());
-
-exit:
-    return error;
 }
 
 void Message::SetOffset(uint16_t aOffset)
diff --git a/src/core/common/message.hpp b/src/core/common/message.hpp
index 53613ed9c..9fe5651ca 100644
--- a/src/core/common/message.hpp
+++ b/src/core/common/message.hpp
@@ -286,11 +286,8 @@ public:
      *
      * @param[in]  aDelta  The number of bytes to move the current offset, which may be positive or negative.
      *
-     * @retval OT_ERROR_NONE          Successfully moved the byte offset.
-     * @retval OT_ERROR_INVALID_ARGS  The resulting byte offset is not within the existing message.
-     *
      */
-    otError MoveOffset(int aDelta);
+    void MoveOffset(int aDelta);
 
     /**
      * This method sets the byte offset within the message.
diff --git a/src/core/meshcop/dtls.cpp b/src/core/meshcop/dtls.cpp
index 37bbef899..138cad85d 100644
--- a/src/core/meshcop/dtls.cpp
+++ b/src/core/meshcop/dtls.cpp
@@ -636,7 +636,7 @@ int Dtls::HandleMbedtlsReceive(unsigned char *aBuf, size_t aLength)
     }
 
     rval = mReceiveMessage->Read(mReceiveMessage->GetOffset(), static_cast<uint16_t>(aLength), aBuf);
-    IgnoreError(mReceiveMessage->MoveOffset(rval));
+    mReceiveMessage->MoveOffset(rval);
 
 exit:
     return rval;
diff --git a/src/core/net/dhcp6_client.cpp b/src/core/net/dhcp6_client.cpp
index 75b3a7f7b..26e9fd3ea 100644
--- a/src/core/net/dhcp6_client.cpp
+++ b/src/core/net/dhcp6_client.cpp
@@ -419,7 +419,7 @@ void Dhcp6Client::HandleUdpReceive(Message &aMessage, const Ip6::MessageInfo &aM
     Dhcp6Header header;
 
     VerifyOrExit(aMessage.Read(aMessage.GetOffset(), sizeof(header), &header) == sizeof(header), OT_NOOP);
-    IgnoreError(aMessage.MoveOffset(sizeof(header)));
+    aMessage.MoveOffset(sizeof(header));
 
     if ((header.GetType() == kTypeReply) && (!memcmp(header.GetTransactionId(), mTransactionId, kTransactionIdSize)))
     {
diff --git a/src/core/net/dhcp6_server.cpp b/src/core/net/dhcp6_server.cpp
index 25d509b13..52499e8fc 100644
--- a/src/core/net/dhcp6_server.cpp
+++ b/src/core/net/dhcp6_server.cpp
@@ -188,7 +188,7 @@ void Dhcp6Server::HandleUdpReceive(Message &aMessage, const Ip6::MessageInfo &aM
     otIp6Address dst = aMessageInfo.mPeerAddr;
 
     VerifyOrExit(aMessage.Read(aMessage.GetOffset(), sizeof(header), &header) == sizeof(header), OT_NOOP);
-    IgnoreError(aMessage.MoveOffset(sizeof(header)));
+    aMessage.MoveOffset(sizeof(header));
 
     // discard if not solicit type
     VerifyOrExit((header.GetType() == kTypeSolicit), OT_NOOP);
diff --git a/src/core/net/dns_client.cpp b/src/core/net/dns_client.cpp
index 472e9abe0..9b439d06e 100644
--- a/src/core/net/dns_client.cpp
+++ b/src/core/net/dns_client.cpp
@@ -479,7 +479,7 @@ void Client::HandleUdpReceive(Message &aMessage, const Ip6::MessageInfo &aMessag
                      !responseHeader.IsTruncationFlagSet(),
                  OT_NOOP);
 
-    IgnoreError(aMessage.MoveOffset(sizeof(responseHeader)));
+    aMessage.MoveOffset(sizeof(responseHeader));
     offset = aMessage.GetOffset();
 
     VerifyOrExit((message = FindRelatedQuery(responseHeader, queryMetadata)) != NULL, OT_NOOP);
diff --git a/src/core/net/icmp6.cpp b/src/core/net/icmp6.cpp
index 1ebd65fcd..51c7e9a51 100644
--- a/src/core/net/icmp6.cpp
+++ b/src/core/net/icmp6.cpp
@@ -158,7 +158,7 @@ otError Icmp::HandleMessage(Message &aMessage, MessageInfo &aMessageInfo)
         SuccessOrExit(error = HandleEchoRequest(aMessage, aMessageInfo));
     }
 
-    IgnoreError(aMessage.MoveOffset(sizeof(icmp6Header)));
+    aMessage.MoveOffset(sizeof(icmp6Header));
 
     for (IcmpHandler *handler = mHandlers.GetHead(); handler; handler = handler->GetNext())
     {
diff --git a/src/core/net/ip6.cpp b/src/core/net/ip6.cpp
index 9b89a1655..60857e3e6 100644
--- a/src/core/net/ip6.cpp
+++ b/src/core/net/ip6.cpp
@@ -578,7 +578,7 @@ otError Ip6::HandleOptions(Message &aMessage, Header &aHeader, bool &aForward)
 
     VerifyOrExit(endOffset <= aMessage.GetLength(), error = OT_ERROR_PARSE);
 
-    IgnoreError(aMessage.MoveOffset(sizeof(optionHeader)));
+    aMessage.MoveOffset(sizeof(optionHeader));
 
     while (aMessage.GetOffset() < endOffset)
     {
@@ -587,7 +587,7 @@ otError Ip6::HandleOptions(Message &aMessage, Header &aHeader, bool &aForward)
 
         if (optionHeader.GetType() == OptionPad1::kType)
         {
-            IgnoreError(aMessage.MoveOffset(sizeof(OptionPad1)));
+            aMessage.MoveOffset(sizeof(OptionPad1));
             continue;
         }
 
@@ -621,7 +621,7 @@ otError Ip6::HandleOptions(Message &aMessage, Header &aHeader, bool &aForward)
             break;
         }
 
-        IgnoreError(aMessage.MoveOffset(sizeof(optionHeader) + optionHeader.GetLength()));
+        aMessage.MoveOffset(sizeof(optionHeader) + optionHeader.GetLength());
     }
 
 exit:
@@ -736,8 +736,7 @@ otError Ip6::HandleFragment(Message &aMessage, Netif *aNetif, MessageInfo &aMess
     if (fragmentHeader.GetOffset() == 0 && !fragmentHeader.IsMoreFlagSet())
     {
         isFragmented = false;
-        error        = aMessage.MoveOffset(sizeof(fragmentHeader));
-
+        aMessage.MoveOffset(sizeof(fragmentHeader));
         ExitNow();
     }
 
@@ -936,7 +935,7 @@ otError Ip6::HandleFragment(Message &aMessage, Netif *aNetif, MessageInfo &aMess
 
     VerifyOrExit(fragmentHeader.GetOffset() == 0 && !fragmentHeader.IsMoreFlagSet(), error = OT_ERROR_DROP);
 
-    IgnoreError(aMessage.MoveOffset(sizeof(fragmentHeader)));
+    aMessage.MoveOffset(sizeof(fragmentHeader));
 
 exit:
     return error;
diff --git a/src/core/net/udp6.cpp b/src/core/net/udp6.cpp
index 2b8d99134..25c5c8774 100644
--- a/src/core/net/udp6.cpp
+++ b/src/core/net/udp6.cpp
@@ -320,7 +320,7 @@ otError Udp::HandleMessage(Message &aMessage, MessageInfo &aMessageInfo)
 
     VerifyOrExit(aMessage.Read(aMessage.GetOffset(), sizeof(udpHeader), &udpHeader) == sizeof(udpHeader),
                  error = OT_ERROR_PARSE);
-    IgnoreError(aMessage.MoveOffset(sizeof(udpHeader)));
+    aMessage.MoveOffset(sizeof(udpHeader));
     aMessageInfo.mPeerPort = udpHeader.GetSourcePort();
     aMessageInfo.mSockPort = udpHeader.GetDestinationPort();
 
diff --git a/src/core/thread/lowpan.cpp b/src/core/thread/lowpan.cpp
index dfcb72bb6..9286d0d03 100644
--- a/src/core/thread/lowpan.cpp
+++ b/src/core/thread/lowpan.cpp
@@ -418,7 +418,7 @@ otError Lowpan::Compress(Message &           aMessage,
 
     headerDepth++;
 
-    IgnoreError(aMessage.MoveOffset(sizeof(ip6Header)));
+    aMessage.MoveOffset(sizeof(ip6Header));
 
     nextHeader = static_cast<uint8_t>(ip6Header.GetNextHeader());
 
@@ -478,7 +478,7 @@ otError Lowpan::CompressExtensionHeader(Message &aMessage, BufferWriter &aBuf, u
 
     VerifyOrExit(aMessage.Read(aMessage.GetOffset(), sizeof(extHeader), &extHeader) == sizeof(extHeader),
                  error = OT_ERROR_PARSE);
-    IgnoreError(aMessage.MoveOffset(sizeof(extHeader)));
+    aMessage.MoveOffset(sizeof(extHeader));
 
     tmpByte = kExtHdrDispatch | kExtHdrEidHbh;
 
@@ -545,7 +545,7 @@ otError Lowpan::CompressExtensionHeader(Message &aMessage, BufferWriter &aBuf, u
 
     SuccessOrExit(error = buf.Write(static_cast<uint8_t>(len)));
     SuccessOrExit(error = buf.Write(aMessage, static_cast<uint8_t>(len)));
-    IgnoreError(aMessage.MoveOffset(len + padLength));
+    aMessage.MoveOffset(len + padLength);
 
 exit:
     if (error == OT_ERROR_NONE)
@@ -602,7 +602,7 @@ otError Lowpan::CompressUdp(Message &aMessage, BufferWriter &aBuf)
 
     SuccessOrExit(error = buf.Write(reinterpret_cast<uint8_t *>(&udpHeader) + Ip6::UdpHeader::GetChecksumOffset(), 2));
 
-    IgnoreError(aMessage.MoveOffset(sizeof(udpHeader)));
+    aMessage.MoveOffset(sizeof(udpHeader));
 
 exit:
     if (error == OT_ERROR_NONE)
@@ -976,11 +976,11 @@ int Lowpan::DecompressExtensionHeader(Message &aMessage, const uint8_t *aBuf, ui
     hdr[1] = BitVectorBytes(sizeof(hdr) + len) - 1;
 
     SuccessOrExit(aMessage.Append(hdr, sizeof(hdr)));
-    IgnoreError(aMessage.MoveOffset(sizeof(hdr)));
+    aMessage.MoveOffset(sizeof(hdr));
 
     // payload
     SuccessOrExit(aMessage.Append(cur, len));
-    IgnoreError(aMessage.MoveOffset(len));
+    aMessage.MoveOffset(len);
     cur += len;
 
     // The RFC6282 says: "The trailing Pad1 or PadN option MAY be elided by the compressor.
@@ -1001,7 +1001,7 @@ int Lowpan::DecompressExtensionHeader(Message &aMessage, const uint8_t *aBuf, ui
             SuccessOrExit(aMessage.Append(&optionPadN, padLength));
         }
 
-        IgnoreError(aMessage.MoveOffset(padLength));
+        aMessage.MoveOffset(padLength);
     }
 
     error = OT_ERROR_NONE;
@@ -1094,7 +1094,7 @@ int Lowpan::DecompressUdpHeader(Message &aMessage, const uint8_t *aBuf, uint16_t
     }
 
     VerifyOrExit(aMessage.Append(&udpHeader, sizeof(udpHeader)) == OT_ERROR_NONE, headerLen = -1);
-    IgnoreError(aMessage.MoveOffset(sizeof(udpHeader)));
+    aMessage.MoveOffset(sizeof(udpHeader));
 
 exit:
     return headerLen;
@@ -1125,7 +1125,7 @@ int Lowpan::Decompress(Message &           aMessage,
     remaining -= rval;
 
     SuccessOrExit(aMessage.Append(&ip6Header, sizeof(ip6Header)));
-    SuccessOrExit(aMessage.MoveOffset(sizeof(ip6Header)));
+    aMessage.MoveOffset(sizeof(ip6Header));
 
     while (compressed)
     {
diff --git a/src/core/thread/mesh_forwarder.cpp b/src/core/thread/mesh_forwarder.cpp
index 4df3a0f3d..827947a19 100644
--- a/src/core/thread/mesh_forwarder.cpp
+++ b/src/core/thread/mesh_forwarder.cpp
@@ -1153,7 +1153,7 @@ void MeshForwarder::HandleFragment(const uint8_t *         aFrame,
         VerifyOrExit(message != NULL, error = OT_ERROR_DROP);
 
         message->Write(message->GetOffset(), aFrameLength, aFrame);
-        IgnoreError(message->MoveOffset(aFrameLength));
+        message->MoveOffset(aFrameLength);
         message->AddRss(aLinkInfo.mRss);
         message->SetTimeout(kReassemblyTimeout);
     }
@@ -1274,7 +1274,7 @@ otError MeshForwarder::FrameToMessage(const uint8_t *     aFrame,
 
     SuccessOrExit(error = aMessage->SetLength(aMessage->GetLength() + aFrameLength));
     aMessage->Write(aMessage->GetOffset(), aFrameLength, aFrame);
-    IgnoreError(aMessage->MoveOffset(aFrameLength));
+    aMessage->MoveOffset(aFrameLength);
 
 exit:
     return error;
diff --git a/src/core/thread/mle.cpp b/src/core/thread/mle.cpp
index 1898a70b4..819bec9b2 100644
--- a/src/core/thread/mle.cpp
+++ b/src/core/thread/mle.cpp
@@ -2557,7 +2557,7 @@ otError Mle::SendMessage(Message &aMessage, const Ip6::Address &aDestination)
             length = aMessage.Read(aMessage.GetOffset(), sizeof(buf), buf);
             aesCcm.Payload(buf, buf, length, true);
             aMessage.Write(aMessage.GetOffset(), length, buf);
-            IgnoreError(aMessage.MoveOffset(length));
+            aMessage.MoveOffset(length);
         }
 
         tagLength = sizeof(tag);
@@ -2630,7 +2630,7 @@ void Mle::HandleUdpReceive(Message &aMessage, const Ip6::MessageInfo &aMessageIn
 
     if (header.GetSecuritySuite() == Header::kNoSecurity)
     {
-        IgnoreError(aMessage.MoveOffset(header.GetLength()));
+        aMessage.MoveOffset(header.GetLength());
 
         switch (header.GetCommand())
         {
@@ -2667,7 +2667,7 @@ void Mle::HandleUdpReceive(Message &aMessage, const Ip6::MessageInfo &aMessageIn
 
     VerifyOrExit(aMessage.GetOffset() + header.GetLength() + sizeof(messageTag) <= aMessage.GetLength(),
                  error = OT_ERROR_PARSE);
-    IgnoreError(aMessage.MoveOffset(header.GetLength() - 1));
+    aMessage.MoveOffset(header.GetLength() - 1);
 
     aMessage.Read(aMessage.GetLength() - sizeof(messageTag), sizeof(messageTag), messageTag);
     SuccessOrExit(error = aMessage.SetLength(aMessage.GetLength() - sizeof(messageTag)));
@@ -2695,7 +2695,7 @@ void Mle::HandleUdpReceive(Message &aMessage, const Ip6::MessageInfo &aMessageIn
 #ifndef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION
         aMessage.Write(aMessage.GetOffset(), length, buf);
 #endif
-        IgnoreError(aMessage.MoveOffset(length));
+        aMessage.MoveOffset(length);
     }
 
     tagLength = sizeof(tag);
@@ -2712,7 +2712,7 @@ void Mle::HandleUdpReceive(Message &aMessage, const Ip6::MessageInfo &aMessageIn
     aMessage.SetOffset(mleOffset);
 
     aMessage.Read(aMessage.GetOffset(), sizeof(command), &command);
-    IgnoreError(aMessage.MoveOffset(sizeof(command)));
+    aMessage.MoveOffset(sizeof(command));
 
     switch (mRole)
     {