diff --git a/pandas/compat/__init__.py b/pandas/compat/__init__.py
index de6b4c9fc6e4a..f9b16419917f2 100644
--- a/pandas/compat/__init__.py
+++ b/pandas/compat/__init__.py
@@ -13,8 +13,6 @@
 from pandas._typing import F
 from pandas.compat.numpy import (
     is_numpy_dev,
-    np_array_datetime64_compat,
-    np_datetime64_compat,
     np_version_under1p19,
     np_version_under1p20,
 )
@@ -130,8 +128,6 @@ def get_lzma_file():
 
 __all__ = [
     "is_numpy_dev",
-    "np_array_datetime64_compat",
-    "np_datetime64_compat",
     "np_version_under1p19",
     "np_version_under1p20",
     "pa_version_under1p01",
diff --git a/pandas/compat/numpy/__init__.py b/pandas/compat/numpy/__init__.py
index 2792a756bf20c..97af4dee3c0de 100644
--- a/pandas/compat/numpy/__init__.py
+++ b/pandas/compat/numpy/__init__.py
@@ -1,7 +1,4 @@
 """ support numpy compatibility across versions """
-
-import re
-
 import numpy as np
 
 from pandas.util.version import Version
@@ -29,44 +26,6 @@
     )
 
 
-_tz_regex = re.compile("[+-]0000$")
-
-
-def _tz_replacer(tstring):
-    if isinstance(tstring, str):
-        if tstring.endswith("Z"):
-            tstring = tstring[:-1]
-        elif _tz_regex.search(tstring):
-            tstring = tstring[:-5]
-    return tstring
-
-
-def np_datetime64_compat(tstring: str, unit: str = "ns"):
-    """
-    provide compat for construction of strings to numpy datetime64's with
-    tz-changes in 1.11 that make '2015-01-01 09:00:00Z' show a deprecation
-    warning, when need to pass '2015-01-01 09:00:00'
-    """
-    tstring = _tz_replacer(tstring)
-    return np.datetime64(tstring, unit)
-
-
-def np_array_datetime64_compat(arr, dtype="M8[ns]"):
-    """
-    provide compat for construction of an array of strings to a
-    np.array(..., dtype=np.datetime64(..))
-    tz-changes in 1.11 that make '2015-01-01 09:00:00Z' show a deprecation
-    warning, when need to pass '2015-01-01 09:00:00'
-    """
-    # is_list_like; can't import as it would be circular
-    if hasattr(arr, "__iter__") and not isinstance(arr, (str, bytes)):
-        arr = [_tz_replacer(s) for s in arr]
-    else:
-        arr = _tz_replacer(arr)
-
-    return np.array(arr, dtype=dtype)
-
-
 __all__ = [
     "np",
     "_np_version",
diff --git a/pandas/tests/arithmetic/test_datetime64.py b/pandas/tests/arithmetic/test_datetime64.py
index 49585f3d37924..3ccb33001c79e 100644
--- a/pandas/tests/arithmetic/test_datetime64.py
+++ b/pandas/tests/arithmetic/test_datetime64.py
@@ -19,7 +19,6 @@
 
 from pandas._libs.tslibs.conversion import localize_pydatetime
 from pandas._libs.tslibs.offsets import shift_months
-from pandas.compat import np_datetime64_compat
 from pandas.errors import PerformanceWarning
 
 import pandas as pd
@@ -487,12 +486,12 @@ def test_dti_cmp_nat_behaves_like_float_cmp_nan(self):
         )
         darr = np.array(
             [
-                np_datetime64_compat("2014-02-01 00:00Z"),
-                np_datetime64_compat("2014-03-01 00:00Z"),
-                np_datetime64_compat("nat"),
+                np.datetime64("2014-02-01 00:00"),
+                np.datetime64("2014-03-01 00:00"),
                 np.datetime64("nat"),
-                np_datetime64_compat("2014-06-01 00:00Z"),
-                np_datetime64_compat("2014-07-01 00:00Z"),
+                np.datetime64("nat"),
+                np.datetime64("2014-06-01 00:00"),
+                np.datetime64("2014-07-01 00:00"),
             ]
         )
 
diff --git a/pandas/tests/base/test_value_counts.py b/pandas/tests/base/test_value_counts.py
index 2970c973b187b..6130646bb52c5 100644
--- a/pandas/tests/base/test_value_counts.py
+++ b/pandas/tests/base/test_value_counts.py
@@ -4,8 +4,6 @@
 import numpy as np
 import pytest
 
-from pandas.compat import np_array_datetime64_compat
-
 import pandas as pd
 from pandas import (
     DatetimeIndex,
@@ -212,7 +210,7 @@ def test_value_counts_datetime64(index_or_series):
     expected_s = Series([3, 2, 1], index=idx)
     tm.assert_series_equal(s.value_counts(), expected_s)
 
-    expected = np_array_datetime64_compat(
+    expected = np.array(
         ["2010-01-01 00:00:00", "2009-01-01 00:00:00", "2008-09-09 00:00:00"],
         dtype="datetime64[ns]",
     )
diff --git a/pandas/tests/indexes/test_index_new.py b/pandas/tests/indexes/test_index_new.py
index deeaffaf5b9cc..f44bbac1226e1 100644
--- a/pandas/tests/indexes/test_index_new.py
+++ b/pandas/tests/indexes/test_index_new.py
@@ -10,8 +10,6 @@
 import numpy as np
 import pytest
 
-from pandas.compat import np_datetime64_compat
-
 from pandas.core.dtypes.common import is_unsigned_integer_dtype
 
 from pandas import (
@@ -273,9 +271,7 @@ def test_constructor_dtypes_to_float64(self, vals):
         [
             [1, 2, 3],
             np.array([1, 2, 3], dtype=int),
-            np.array(
-                [np_datetime64_compat("2011-01-01"), np_datetime64_compat("2011-01-02")]
-            ),
+            np.array(["2011-01-01", "2011-01-02"], dtype="datetime64[ns]"),
             [datetime(2011, 1, 1), datetime(2011, 1, 2)],
         ],
     )
@@ -287,14 +283,7 @@ def test_constructor_dtypes_to_categorical(self, vals):
     @pytest.mark.parametrize(
         "vals",
         [
-            Index(
-                np.array(
-                    [
-                        np_datetime64_compat("2011-01-01"),
-                        np_datetime64_compat("2011-01-02"),
-                    ]
-                )
-            ),
+            Index(np.array([np.datetime64("2011-01-01"), np.datetime64("2011-01-02")])),
             Index([datetime(2011, 1, 1), datetime(2011, 1, 2)]),
         ],
     )
diff --git a/pandas/tests/io/parser/test_parse_dates.py b/pandas/tests/io/parser/test_parse_dates.py
index 68fc86c9586ee..1dfd81366de72 100644
--- a/pandas/tests/io/parser/test_parse_dates.py
+++ b/pandas/tests/io/parser/test_parse_dates.py
@@ -21,7 +21,6 @@
 
 from pandas._libs.tslibs import parsing
 from pandas._libs.tslibs.parsing import parse_datetime_string
-from pandas.compat import np_array_datetime64_compat
 from pandas.compat.pyarrow import pa_version_under6p0
 
 import pandas as pd
@@ -1541,7 +1540,7 @@ def test_date_parser_resolution_if_not_ns(all_parsers):
 """
 
     def date_parser(dt, time):
-        return np_array_datetime64_compat(dt + "T" + time + "Z", dtype="datetime64[s]")
+        return np.array(dt + "T" + time, dtype="datetime64[s]")
 
     result = parser.read_csv(
         StringIO(data),
@@ -1550,9 +1549,7 @@ def date_parser(dt, time):
         index_col=["datetime", "prn"],
     )
 
-    datetimes = np_array_datetime64_compat(
-        ["2013-11-03T19:00:00Z"] * 3, dtype="datetime64[s]"
-    )
+    datetimes = np.array(["2013-11-03T19:00:00"] * 3, dtype="datetime64[s]")
     expected = DataFrame(
         data={"rxstatus": ["00E80000"] * 3},
         index=MultiIndex.from_tuples(
diff --git a/pandas/tests/plotting/test_converter.py b/pandas/tests/plotting/test_converter.py
index 1d9b14a739848..fe8620ef76c4b 100644
--- a/pandas/tests/plotting/test_converter.py
+++ b/pandas/tests/plotting/test_converter.py
@@ -10,7 +10,6 @@
 
 import pandas._config.config as cf
 
-from pandas.compat import np_datetime64_compat
 import pandas.util._test_decorators as td
 
 from pandas import (
@@ -185,21 +184,14 @@ def test_conversion(self):
         assert rs == xp
 
         # also testing datetime64 dtype (GH8614)
-        rs = self.dtc.convert(np_datetime64_compat("2012-01-01"), None, None)
+        rs = self.dtc.convert("2012-01-01", None, None)
         assert rs == xp
 
-        rs = self.dtc.convert(
-            np_datetime64_compat("2012-01-01 00:00:00+0000"), None, None
-        )
+        rs = self.dtc.convert("2012-01-01 00:00:00+0000", None, None)
         assert rs == xp
 
         rs = self.dtc.convert(
-            np.array(
-                [
-                    np_datetime64_compat("2012-01-01 00:00:00+0000"),
-                    np_datetime64_compat("2012-01-02 00:00:00+0000"),
-                ]
-            ),
+            np.array(["2012-01-01 00:00:00+0000", "2012-01-02 00:00:00+0000"]),
             None,
             None,
         )
@@ -334,20 +326,16 @@ def test_conversion(self):
         rs = self.pc.convert(Timestamp("2012-1-1"), None, self.axis)
         assert rs == xp
 
-        rs = self.pc.convert(np_datetime64_compat("2012-01-01"), None, self.axis)
+        rs = self.pc.convert("2012-01-01", None, self.axis)
         assert rs == xp
 
-        rs = self.pc.convert(
-            np_datetime64_compat("2012-01-01 00:00:00+0000"), None, self.axis
-        )
+        rs = self.pc.convert("2012-01-01 00:00:00+0000", None, self.axis)
         assert rs == xp
 
         rs = self.pc.convert(
             np.array(
-                [
-                    np_datetime64_compat("2012-01-01 00:00:00+0000"),
-                    np_datetime64_compat("2012-01-02 00:00:00+0000"),
-                ]
+                ["2012-01-01 00:00:00+0000", "2012-01-02 00:00:00+0000"],
+                dtype="datetime64[ns]",
             ),
             None,
             self.axis,
diff --git a/pandas/tests/scalar/period/test_period.py b/pandas/tests/scalar/period/test_period.py
index f35033115d2fc..7d437f3b47274 100644
--- a/pandas/tests/scalar/period/test_period.py
+++ b/pandas/tests/scalar/period/test_period.py
@@ -26,7 +26,6 @@
     dateutil_gettz,
     maybe_get_tz,
 )
-from pandas.compat import np_datetime64_compat
 
 import pandas as pd
 from pandas import (
@@ -92,14 +91,14 @@ def test_construction(self):
         expected = Period(datetime(2007, 1, 1, 9, 0, 0, 1000), freq="L")
         assert i1 == expected
 
-        expected = Period(np_datetime64_compat("2007-01-01 09:00:00.001Z"), freq="L")
+        expected = Period("2007-01-01 09:00:00.001", freq="L")
         assert i1 == expected
 
         i1 = Period("2007-01-01 09:00:00.00101")
         expected = Period(datetime(2007, 1, 1, 9, 0, 0, 1010), freq="U")
         assert i1 == expected
 
-        expected = Period(np_datetime64_compat("2007-01-01 09:00:00.00101Z"), freq="U")
+        expected = Period("2007-01-01 09:00:00.00101", freq="U")
         assert i1 == expected
 
         msg = "Must supply freq for ordinal value"
@@ -190,8 +189,8 @@ def test_construction_month(self):
         i1 = Period(date(2007, 1, 1), freq="M")
         i2 = Period(datetime(2007, 1, 1), freq="M")
         i3 = Period(np.datetime64("2007-01-01"), freq="M")
-        i4 = Period(np_datetime64_compat("2007-01-01 00:00:00Z"), freq="M")
-        i5 = Period(np_datetime64_compat("2007-01-01 00:00:00.000Z"), freq="M")
+        i4 = Period("2007-01-01 00:00:00", freq="M")
+        i5 = Period("2007-01-01 00:00:00.000", freq="M")
         assert i1 == i2
         assert i1 == i3
         assert i1 == i4
@@ -245,8 +244,8 @@ def test_period_constructor_offsets(self):
         i1 = Period(date(2007, 1, 1), freq="M")
         i2 = Period(datetime(2007, 1, 1), freq="M")
         i3 = Period(np.datetime64("2007-01-01"), freq="M")
-        i4 = Period(np_datetime64_compat("2007-01-01 00:00:00Z"), freq="M")
-        i5 = Period(np_datetime64_compat("2007-01-01 00:00:00.000Z"), freq="M")
+        i4 = Period("2007-01-01 00:00:00", freq="M")
+        i5 = Period("2007-01-01 00:00:00.000", freq="M")
         assert i1 == i2
         assert i1 == i3
         assert i1 == i4
@@ -256,14 +255,14 @@ def test_period_constructor_offsets(self):
         expected = Period(datetime(2007, 1, 1, 9, 0, 0, 1000), freq="L")
         assert i1 == expected
 
-        expected = Period(np_datetime64_compat("2007-01-01 09:00:00.001Z"), freq="L")
+        expected = Period("2007-01-01 09:00:00.001", freq="L")
         assert i1 == expected
 
         i1 = Period("2007-01-01 09:00:00.00101")
         expected = Period(datetime(2007, 1, 1, 9, 0, 0, 1010), freq="U")
         assert i1 == expected
 
-        expected = Period(np_datetime64_compat("2007-01-01 09:00:00.00101Z"), freq="U")
+        expected = Period("2007-01-01 09:00:00.00101", freq="U")
         assert i1 == expected
 
     def test_invalid_arguments(self):
diff --git a/pandas/tests/scalar/timestamp/test_timestamp.py b/pandas/tests/scalar/timestamp/test_timestamp.py
index b3abec6b9761f..03ba6b12599a6 100644
--- a/pandas/tests/scalar/timestamp/test_timestamp.py
+++ b/pandas/tests/scalar/timestamp/test_timestamp.py
@@ -22,7 +22,6 @@
     dateutil_gettz as gettz,
     get_timezone,
 )
-from pandas.compat import np_datetime64_compat
 import pandas.util._test_decorators as td
 
 from pandas import (
@@ -492,7 +491,7 @@ def test_nanosecond_timestamp(self):
         assert t.value == expected
         assert t.nanosecond == 5
 
-        t = Timestamp(np_datetime64_compat("2011-01-01 00:00:00.000000005Z"))
+        t = Timestamp("2011-01-01 00:00:00.000000005")
         assert repr(t) == "Timestamp('2011-01-01 00:00:00.000000005')"
         assert t.value == expected
         assert t.nanosecond == 5
@@ -508,7 +507,7 @@ def test_nanosecond_timestamp(self):
         assert t.value == expected
         assert t.nanosecond == 10
 
-        t = Timestamp(np_datetime64_compat("2011-01-01 00:00:00.000000010Z"))
+        t = Timestamp("2011-01-01 00:00:00.000000010")
         assert repr(t) == "Timestamp('2011-01-01 00:00:00.000000010')"
         assert t.value == expected
         assert t.nanosecond == 10
diff --git a/pandas/tests/series/methods/test_asof.py b/pandas/tests/series/methods/test_asof.py
index 8ddcf07934e21..7ede868861ac0 100644
--- a/pandas/tests/series/methods/test_asof.py
+++ b/pandas/tests/series/methods/test_asof.py
@@ -2,7 +2,6 @@
 import pytest
 
 from pandas._libs.tslibs import IncompatibleFrequency
-from pandas.compat import np_datetime64_compat
 
 from pandas import (
     DatetimeIndex,
@@ -28,7 +27,7 @@ def test_asof_nanosecond_index_access(self):
         #  handle nanoseconds
         assert first_value == ser["2013-01-01 00:00:00.000000050+0000"]
 
-        expected_ts = np_datetime64_compat("2013-01-01 00:00:00.000000050+0000", "ns")
+        expected_ts = np.datetime64("2013-01-01 00:00:00.000000050", "ns")
         assert first_value == ser[Timestamp(expected_ts)]
 
     def test_basic(self):
diff --git a/pandas/tests/test_algos.py b/pandas/tests/test_algos.py
index 1345a66673d1c..6188e3c3b0de9 100644
--- a/pandas/tests/test_algos.py
+++ b/pandas/tests/test_algos.py
@@ -9,7 +9,6 @@
     algos as libalgos,
     hashtable as ht,
 )
-from pandas.compat import np_array_datetime64_compat
 import pandas.util._test_decorators as td
 
 from pandas.core.dtypes.common import (
@@ -537,10 +536,10 @@ def test_dtype_preservation(self, any_numpy_dtype):
 
     def test_datetime64_dtype_array_returned(self):
         # GH 9431
-        expected = np_array_datetime64_compat(
+        expected = np.array(
             [
-                "2015-01-03T00:00:00.000000000+0000",
-                "2015-01-01T00:00:00.000000000+0000",
+                "2015-01-03T00:00:00.000000000",
+                "2015-01-01T00:00:00.000000000",
             ],
             dtype="M8[ns]",
         )
diff --git a/pandas/tests/tseries/offsets/test_business_day.py b/pandas/tests/tseries/offsets/test_business_day.py
index c40ae611687dd..482d697b15e98 100644
--- a/pandas/tests/tseries/offsets/test_business_day.py
+++ b/pandas/tests/tseries/offsets/test_business_day.py
@@ -7,6 +7,7 @@
     timedelta,
 )
 
+import numpy as np
 import pytest
 
 from pandas._libs.tslibs.offsets import (
@@ -14,7 +15,6 @@
     BDay,
     BMonthEnd,
 )
-from pandas.compat import np_datetime64_compat
 
 from pandas import (
     DatetimeIndex,
@@ -36,7 +36,7 @@ class TestBusinessDay(Base):
 
     def setup_method(self, method):
         self.d = datetime(2008, 1, 1)
-        self.nd = np_datetime64_compat("2008-01-01 00:00:00Z")
+        self.nd = np.datetime64("2008-01-01 00:00:00")
 
         self.offset = self._offset()
         self.offset1 = self.offset
diff --git a/pandas/tests/tseries/offsets/test_offsets.py b/pandas/tests/tseries/offsets/test_offsets.py
index 134ba79e7773d..6cec35939dff2 100644
--- a/pandas/tests/tseries/offsets/test_offsets.py
+++ b/pandas/tests/tseries/offsets/test_offsets.py
@@ -28,7 +28,6 @@
     _offset_map,
 )
 from pandas._libs.tslibs.period import INVALID_FREQ_ERR_MSG
-from pandas.compat import np_datetime64_compat
 from pandas.errors import PerformanceWarning
 
 from pandas import DatetimeIndex
@@ -101,7 +100,7 @@ class TestCommon(Base):
         "Second": Timestamp("2011-01-01 09:00:01"),
         "Milli": Timestamp("2011-01-01 09:00:00.001000"),
         "Micro": Timestamp("2011-01-01 09:00:00.000001"),
-        "Nano": Timestamp(np_datetime64_compat("2011-01-01T09:00:00.000000001Z")),
+        "Nano": Timestamp("2011-01-01T09:00:00.000000001"),
     }
 
     def test_immutable(self, offset_types):
@@ -252,7 +251,7 @@ def _check_offsetfunc_works(self, offset, funcname, dt, expected, normalize=Fals
 
     def test_apply(self, offset_types):
         sdt = datetime(2011, 1, 1, 9, 0)
-        ndt = np_datetime64_compat("2011-01-01 09:00Z")
+        ndt = np.datetime64("2011-01-01 09:00")
 
         expected = self.expecteds[offset_types.__name__]
         expected_norm = Timestamp(expected.date())
@@ -309,7 +308,7 @@ def test_rollforward(self, offset_types):
         norm_expected.update(normalized)
 
         sdt = datetime(2011, 1, 1, 9, 0)
-        ndt = np_datetime64_compat("2011-01-01 09:00Z")
+        ndt = np.datetime64("2011-01-01 09:00")
 
         for dt in [sdt, ndt]:
             expected = expecteds[offset_types.__name__]
@@ -383,7 +382,7 @@ def test_rollback(self, offset_types):
         norm_expected.update(normalized)
 
         sdt = datetime(2011, 1, 1, 9, 0)
-        ndt = np_datetime64_compat("2011-01-01 09:00Z")
+        ndt = np.datetime64("2011-01-01 09:00")
 
         for dt in [sdt, ndt]:
             expected = expecteds[offset_types.__name__]
diff --git a/pandas/tests/tslibs/test_array_to_datetime.py b/pandas/tests/tslibs/test_array_to_datetime.py
index 8c2f0b09c461e..a0fafc227e001 100644
--- a/pandas/tests/tslibs/test_array_to_datetime.py
+++ b/pandas/tests/tslibs/test_array_to_datetime.py
@@ -12,7 +12,6 @@
     iNaT,
     tslib,
 )
-from pandas.compat import np_array_datetime64_compat
 
 from pandas import Timestamp
 import pandas._testing as tm
@@ -24,15 +23,15 @@
         (
             ["01-01-2013", "01-02-2013"],
             [
-                "2013-01-01T00:00:00.000000000-0000",
-                "2013-01-02T00:00:00.000000000-0000",
+                "2013-01-01T00:00:00.000000000",
+                "2013-01-02T00:00:00.000000000",
             ],
         ),
         (
             ["Mon Sep 16 2013", "Tue Sep 17 2013"],
             [
-                "2013-09-16T00:00:00.000000000-0000",
-                "2013-09-17T00:00:00.000000000-0000",
+                "2013-09-16T00:00:00.000000000",
+                "2013-09-17T00:00:00.000000000",
             ],
         ),
     ],
@@ -41,7 +40,7 @@ def test_parsing_valid_dates(data, expected):
     arr = np.array(data, dtype=object)
     result, _ = tslib.array_to_datetime(arr)
 
-    expected = np_array_datetime64_compat(expected, dtype="M8[ns]")
+    expected = np.array(expected, dtype="M8[ns]")
     tm.assert_numpy_array_equal(result, expected)
 
 
@@ -141,8 +140,8 @@ def test_coerce_outside_ns_bounds_one_valid():
     arr = np.array(["1/1/1000", "1/1/2000"], dtype=object)
     result, _ = tslib.array_to_datetime(arr, errors="coerce")
 
-    expected = [iNaT, "2000-01-01T00:00:00.000000000-0000"]
-    expected = np_array_datetime64_compat(expected, dtype="M8[ns]")
+    expected = [iNaT, "2000-01-01T00:00:00.000000000"]
+    expected = np.array(expected, dtype="M8[ns]")
 
     tm.assert_numpy_array_equal(result, expected)
 
@@ -160,11 +159,9 @@ def test_coerce_of_invalid_datetimes(errors):
     else:  # coerce.
         # With coercing, the invalid dates becomes iNaT
         result, _ = tslib.array_to_datetime(arr, errors="coerce")
-        expected = ["2013-01-01T00:00:00.000000000-0000", iNaT, iNaT]
+        expected = ["2013-01-01T00:00:00.000000000", iNaT, iNaT]
 
-        tm.assert_numpy_array_equal(
-            result, np_array_datetime64_compat(expected, dtype="M8[ns]")
-        )
+        tm.assert_numpy_array_equal(result, np.array(expected, dtype="M8[ns]"))
 
 
 def test_to_datetime_barely_out_of_bounds():
@@ -186,9 +183,9 @@ class SubDatetime(datetime):
 @pytest.mark.parametrize(
     "data,expected",
     [
-        ([SubDatetime(2000, 1, 1)], ["2000-01-01T00:00:00.000000000-0000"]),
-        ([datetime(2000, 1, 1)], ["2000-01-01T00:00:00.000000000-0000"]),
-        ([Timestamp(2000, 1, 1)], ["2000-01-01T00:00:00.000000000-0000"]),
+        ([SubDatetime(2000, 1, 1)], ["2000-01-01T00:00:00.000000000"]),
+        ([datetime(2000, 1, 1)], ["2000-01-01T00:00:00.000000000"]),
+        ([Timestamp(2000, 1, 1)], ["2000-01-01T00:00:00.000000000"]),
     ],
 )
 def test_datetime_subclass(data, expected):
@@ -199,5 +196,5 @@ def test_datetime_subclass(data, expected):
     arr = np.array(data, dtype=object)
     result, _ = tslib.array_to_datetime(arr)
 
-    expected = np_array_datetime64_compat(expected, dtype="M8[ns]")
+    expected = np.array(expected, dtype="M8[ns]")
     tm.assert_numpy_array_equal(result, expected)