diff --git a/src/CONST.js b/src/CONST.js
index e8c95b83f57e..2b7f183b82b9 100755
--- a/src/CONST.js
+++ b/src/CONST.js
@@ -128,6 +128,14 @@ const CONST = {
         MOMENT_FORMAT_STRING: 'YYYY-MM-DD',
         SQL_DATE_TIME: 'YYYY-MM-DD HH:mm:ss',
         FNS_FORMAT_STRING: 'yyyy-MM-dd',
+        LOCAL_TIME_FORMAT: 'hh:mm a',
+        WEEKDAY_TIME_FORMAT: 'eeee',
+        MONTH_DAY_ABBR_FORMAT: 'MMM d',
+        SHORT_DATE_FORMAT: 'MM-dd',
+        MONTH_DAY_YEAR_ABBR_FORMAT: 'MMM d, yyyy',
+        FNS_TIMEZONE_FORMAT_STRING: "yyyy-MM-dd'T'HH:mm:ssXXX",
+        FNS_DB_FORMAT_STRING: 'yyyy-MM-dd HH:mm:ss.SSS',
+        LONG_DATE_FORMAT_WITH_WEEKDAY: 'eeee, MMMM d, yyyy',
         UNIX_EPOCH: '1970-01-01 00:00:00.000',
         MAX_DATE: '9999-12-31',
         MIN_DATE: '0001-01-01',
diff --git a/src/TIMEZONES.js b/src/TIMEZONES.js
new file mode 100644
index 000000000000..2a596b51e8b3
--- /dev/null
+++ b/src/TIMEZONES.js
@@ -0,0 +1,421 @@
+// All timezones were taken from: https://raw.githubusercontent.com/leon-do/Timezones/main/timezone.json
+export default [
+    'Africa/Abidjan',
+    'Africa/Accra',
+    'Africa/Addis_Ababa',
+    'Africa/Algiers',
+    'Africa/Asmara',
+    'Africa/Bamako',
+    'Africa/Bangui',
+    'Africa/Banjul',
+    'Africa/Bissau',
+    'Africa/Blantyre',
+    'Africa/Brazzaville',
+    'Africa/Bujumbura',
+    'Africa/Cairo',
+    'Africa/Casablanca',
+    'Africa/Ceuta',
+    'Africa/Conakry',
+    'Africa/Dakar',
+    'Africa/Dar_es_Salaam',
+    'Africa/Djibouti',
+    'Africa/Douala',
+    'Africa/El_Aaiun',
+    'Africa/Freetown',
+    'Africa/Gaborone',
+    'Africa/Harare',
+    'Africa/Johannesburg',
+    'Africa/Juba',
+    'Africa/Kampala',
+    'Africa/Khartoum',
+    'Africa/Kigali',
+    'Africa/Kinshasa',
+    'Africa/Lagos',
+    'Africa/Libreville',
+    'Africa/Lome',
+    'Africa/Luanda',
+    'Africa/Lubumbashi',
+    'Africa/Lusaka',
+    'Africa/Malabo',
+    'Africa/Maputo',
+    'Africa/Maseru',
+    'Africa/Mbabane',
+    'Africa/Mogadishu',
+    'Africa/Monrovia',
+    'Africa/Nairobi',
+    'Africa/Ndjamena',
+    'Africa/Niamey',
+    'Africa/Nouakchott',
+    'Africa/Ouagadougou',
+    'Africa/Porto-Novo',
+    'Africa/Sao_Tome',
+    'Africa/Tripoli',
+    'Africa/Tunis',
+    'Africa/Windhoek',
+    'America/Adak',
+    'America/Anchorage',
+    'America/Anguilla',
+    'America/Antigua',
+    'America/Araguaina',
+    'America/Argentina/Buenos_Aires',
+    'America/Argentina/Catamarca',
+    'America/Argentina/Cordoba',
+    'America/Argentina/Jujuy',
+    'America/Argentina/La_Rioja',
+    'America/Argentina/Mendoza',
+    'America/Argentina/Rio_Gallegos',
+    'America/Argentina/Salta',
+    'America/Argentina/San_Juan',
+    'America/Argentina/San_Luis',
+    'America/Argentina/Tucuman',
+    'America/Argentina/Ushuaia',
+    'America/Aruba',
+    'America/Asuncion',
+    'America/Atikokan',
+    'America/Bahia',
+    'America/Bahia_Banderas',
+    'America/Barbados',
+    'America/Belem',
+    'America/Belize',
+    'America/Blanc-Sablon',
+    'America/Boa_Vista',
+    'America/Bogota',
+    'America/Boise',
+    'America/Cambridge_Bay',
+    'America/Campo_Grande',
+    'America/Cancun',
+    'America/Caracas',
+    'America/Cayenne',
+    'America/Cayman',
+    'America/Chicago',
+    'America/Chihuahua',
+    'America/Ciudad_Juarez',
+    'America/Costa_Rica',
+    'America/Creston',
+    'America/Cuiaba',
+    'America/Curacao',
+    'America/Danmarkshavn',
+    'America/Dawson',
+    'America/Dawson_Creek',
+    'America/Denver',
+    'America/Detroit',
+    'America/Dominica',
+    'America/Edmonton',
+    'America/Eirunepe',
+    'America/El_Salvador',
+    'America/Fort_Nelson',
+    'America/Fortaleza',
+    'America/Glace_Bay',
+    'America/Goose_Bay',
+    'America/Grand_Turk',
+    'America/Grenada',
+    'America/Guadeloupe',
+    'America/Guatemala',
+    'America/Guayaquil',
+    'America/Guyana',
+    'America/Halifax',
+    'America/Havana',
+    'America/Hermosillo',
+    'America/Indiana/Indianapolis',
+    'America/Indiana/Knox',
+    'America/Indiana/Marengo',
+    'America/Indiana/Petersburg',
+    'America/Indiana/Tell_City',
+    'America/Indiana/Vevay',
+    'America/Indiana/Vincennes',
+    'America/Indiana/Winamac',
+    'America/Inuvik',
+    'America/Iqaluit',
+    'America/Jamaica',
+    'America/Juneau',
+    'America/Kentucky/Louisville',
+    'America/Kentucky/Monticello',
+    'America/Kralendijk',
+    'America/La_Paz',
+    'America/Lima',
+    'America/Los_Angeles',
+    'America/Lower_Princes',
+    'America/Maceio',
+    'America/Managua',
+    'America/Manaus',
+    'America/Marigot',
+    'America/Martinique',
+    'America/Matamoros',
+    'America/Mazatlan',
+    'America/Menominee',
+    'America/Merida',
+    'America/Metlakatla',
+    'America/Mexico_City',
+    'America/Miquelon',
+    'America/Moncton',
+    'America/Monterrey',
+    'America/Montevideo',
+    'America/Montserrat',
+    'America/Nassau',
+    'America/New_York',
+    'America/Nome',
+    'America/Noronha',
+    'America/North_Dakota/Beulah',
+    'America/North_Dakota/Center',
+    'America/North_Dakota/New_Salem',
+    'America/Nuuk',
+    'America/Ojinaga',
+    'America/Panama',
+    'America/Paramaribo',
+    'America/Phoenix',
+    'America/Port-au-Prince',
+    'America/Port_of_Spain',
+    'America/Porto_Velho',
+    'America/Puerto_Rico',
+    'America/Punta_Arenas',
+    'America/Rankin_Inlet',
+    'America/Recife',
+    'America/Regina',
+    'America/Resolute',
+    'America/Rio_Branco',
+    'America/Santarem',
+    'America/Santiago',
+    'America/Santo_Domingo',
+    'America/Sao_Paulo',
+    'America/Scoresbysund',
+    'America/Sitka',
+    'America/St_Barthelemy',
+    'America/St_Johns',
+    'America/St_Kitts',
+    'America/St_Lucia',
+    'America/St_Thomas',
+    'America/St_Vincent',
+    'America/Swift_Current',
+    'America/Tegucigalpa',
+    'America/Thule',
+    'America/Tijuana',
+    'America/Toronto',
+    'America/Tortola',
+    'America/Vancouver',
+    'America/Whitehorse',
+    'America/Winnipeg',
+    'America/Yakutat',
+    'Antarctica/Casey',
+    'Antarctica/Davis',
+    'Antarctica/DumontDUrville',
+    'Antarctica/Macquarie',
+    'Antarctica/Mawson',
+    'Antarctica/McMurdo',
+    'Antarctica/Palmer',
+    'Antarctica/Rothera',
+    'Antarctica/Syowa',
+    'Antarctica/Troll',
+    'Antarctica/Vostok',
+    'Arctic/Longyearbyen',
+    'Asia/Aden',
+    'Asia/Almaty',
+    'Asia/Amman',
+    'Asia/Anadyr',
+    'Asia/Aqtau',
+    'Asia/Aqtobe',
+    'Asia/Ashgabat',
+    'Asia/Atyrau',
+    'Asia/Baghdad',
+    'Asia/Bahrain',
+    'Asia/Baku',
+    'Asia/Bangkok',
+    'Asia/Barnaul',
+    'Asia/Beirut',
+    'Asia/Bishkek',
+    'Asia/Brunei',
+    'Asia/Chita',
+    'Asia/Choibalsan',
+    'Asia/Colombo',
+    'Asia/Damascus',
+    'Asia/Dhaka',
+    'Asia/Dili',
+    'Asia/Dubai',
+    'Asia/Dushanbe',
+    'Asia/Famagusta',
+    'Asia/Gaza',
+    'Asia/Hebron',
+    'Asia/Ho_Chi_Minh',
+    'Asia/Hong_Kong',
+    'Asia/Hovd',
+    'Asia/Irkutsk',
+    'Asia/Jakarta',
+    'Asia/Jayapura',
+    'Asia/Jerusalem',
+    'Asia/Kabul',
+    'Asia/Kamchatka',
+    'Asia/Karachi',
+    'Asia/Kathmandu',
+    'Asia/Khandyga',
+    'Asia/Kolkata',
+    'Asia/Krasnoyarsk',
+    'Asia/Kuala_Lumpur',
+    'Asia/Kuching',
+    'Asia/Kuwait',
+    'Asia/Macau',
+    'Asia/Magadan',
+    'Asia/Makassar',
+    'Asia/Manila',
+    'Asia/Muscat',
+    'Asia/Nicosia',
+    'Asia/Novokuznetsk',
+    'Asia/Novosibirsk',
+    'Asia/Omsk',
+    'Asia/Oral',
+    'Asia/Phnom_Penh',
+    'Asia/Pontianak',
+    'Asia/Pyongyang',
+    'Asia/Qatar',
+    'Asia/Qostanay',
+    'Asia/Qyzylorda',
+    'Asia/Riyadh',
+    'Asia/Sakhalin',
+    'Asia/Samarkand',
+    'Asia/Seoul',
+    'Asia/Shanghai',
+    'Asia/Singapore',
+    'Asia/Srednekolymsk',
+    'Asia/Taipei',
+    'Asia/Tashkent',
+    'Asia/Tbilisi',
+    'Asia/Tehran',
+    'Asia/Thimphu',
+    'Asia/Tokyo',
+    'Asia/Tomsk',
+    'Asia/Ulaanbaatar',
+    'Asia/Urumqi',
+    'Asia/Ust-Nera',
+    'Asia/Vientiane',
+    'Asia/Vladivostok',
+    'Asia/Yakutsk',
+    'Asia/Yangon',
+    'Asia/Yekaterinburg',
+    'Asia/Yerevan',
+    'Atlantic/Azores',
+    'Atlantic/Bermuda',
+    'Atlantic/Canary',
+    'Atlantic/Cape_Verde',
+    'Atlantic/Faroe',
+    'Atlantic/Madeira',
+    'Atlantic/Reykjavik',
+    'Atlantic/South_Georgia',
+    'Atlantic/St_Helena',
+    'Atlantic/Stanley',
+    'Australia/Adelaide',
+    'Australia/Brisbane',
+    'Australia/Broken_Hill',
+    'Australia/Darwin',
+    'Australia/Eucla',
+    'Australia/Hobart',
+    'Australia/Lindeman',
+    'Australia/Lord_Howe',
+    'Australia/Melbourne',
+    'Australia/Perth',
+    'Australia/Sydney',
+    'Europe/Amsterdam',
+    'Europe/Andorra',
+    'Europe/Astrakhan',
+    'Europe/Athens',
+    'Europe/Belgrade',
+    'Europe/Berlin',
+    'Europe/Bratislava',
+    'Europe/Brussels',
+    'Europe/Bucharest',
+    'Europe/Budapest',
+    'Europe/Busingen',
+    'Europe/Chisinau',
+    'Europe/Copenhagen',
+    'Europe/Dublin',
+    'Europe/Gibraltar',
+    'Europe/Guernsey',
+    'Europe/Helsinki',
+    'Europe/Isle_of_Man',
+    'Europe/Istanbul',
+    'Europe/Jersey',
+    'Europe/Kaliningrad',
+    'Europe/Kirov',
+    'Europe/Kyiv',
+    'Europe/Lisbon',
+    'Europe/Ljubljana',
+    'Europe/London',
+    'Europe/Luxembourg',
+    'Europe/Madrid',
+    'Europe/Malta',
+    'Europe/Mariehamn',
+    'Europe/Minsk',
+    'Europe/Monaco',
+    'Europe/Moscow',
+    'Europe/Oslo',
+    'Europe/Paris',
+    'Europe/Podgorica',
+    'Europe/Prague',
+    'Europe/Riga',
+    'Europe/Rome',
+    'Europe/Samara',
+    'Europe/San_Marino',
+    'Europe/Sarajevo',
+    'Europe/Saratov',
+    'Europe/Simferopol',
+    'Europe/Skopje',
+    'Europe/Sofia',
+    'Europe/Stockholm',
+    'Europe/Tallinn',
+    'Europe/Tirane',
+    'Europe/Ulyanovsk',
+    'Europe/Vaduz',
+    'Europe/Vatican',
+    'Europe/Vienna',
+    'Europe/Vilnius',
+    'Europe/Volgograd',
+    'Europe/Warsaw',
+    'Europe/Zagreb',
+    'Europe/Zurich',
+    'Indian/Antananarivo',
+    'Indian/Chagos',
+    'Indian/Christmas',
+    'Indian/Cocos',
+    'Indian/Comoro',
+    'Indian/Kerguelen',
+    'Indian/Mahe',
+    'Indian/Maldives',
+    'Indian/Mauritius',
+    'Indian/Mayotte',
+    'Indian/Reunion',
+    'Pacific/Apia',
+    'Pacific/Auckland',
+    'Pacific/Bougainville',
+    'Pacific/Chatham',
+    'Pacific/Chuuk',
+    'Pacific/Easter',
+    'Pacific/Efate',
+    'Pacific/Fakaofo',
+    'Pacific/Fiji',
+    'Pacific/Funafuti',
+    'Pacific/Galapagos',
+    'Pacific/Gambier',
+    'Pacific/Guadalcanal',
+    'Pacific/Guam',
+    'Pacific/Honolulu',
+    'Pacific/Kanton',
+    'Pacific/Kiritimati',
+    'Pacific/Kosrae',
+    'Pacific/Kwajalein',
+    'Pacific/Majuro',
+    'Pacific/Marquesas',
+    'Pacific/Midway',
+    'Pacific/Nauru',
+    'Pacific/Niue',
+    'Pacific/Norfolk',
+    'Pacific/Noumea',
+    'Pacific/Pago_Pago',
+    'Pacific/Palau',
+    'Pacific/Pitcairn',
+    'Pacific/Pohnpei',
+    'Pacific/Port_Moresby',
+    'Pacific/Rarotonga',
+    'Pacific/Saipan',
+    'Pacific/Tahiti',
+    'Pacific/Tarawa',
+    'Pacific/Tongatapu',
+    'Pacific/Wake',
+    'Pacific/Wallis',
+];
diff --git a/src/components/AutoUpdateTime.js b/src/components/AutoUpdateTime.js
index a522a3e6dcdc..cb15cb20b4ea 100644
--- a/src/components/AutoUpdateTime.js
+++ b/src/components/AutoUpdateTime.js
@@ -27,21 +27,13 @@ function AutoUpdateTime(props) {
      * @returns {moment} Returns the locale moment object
      */
     const getCurrentUserLocalTime = useCallback(
-        () => DateUtils.getLocalMomentFromDatetime(props.preferredLocale, null, props.timezone.selected),
+        () => DateUtils.getLocalDateFromDatetime(props.preferredLocale, null, props.timezone.selected),
         [props.preferredLocale, props.timezone.selected],
     );
 
     const [currentUserLocalTime, setCurrentUserLocalTime] = useState(getCurrentUserLocalTime);
     const minuteRef = useRef(new Date().getMinutes());
-    const timezoneName = useMemo(() => {
-        // With non-GMT timezone, moment.zoneAbbr() will return the name of that timezone, so we can use it directly.
-        if (Number.isNaN(Number(currentUserLocalTime.zoneAbbr()))) {
-            return currentUserLocalTime.zoneAbbr();
-        }
-
-        // With GMT timezone, moment.zoneAbbr() will return a number, so we need to display it as GMT {abbreviations} format, e.g.: GMT +07
-        return `GMT ${currentUserLocalTime.zoneAbbr()}`;
-    }, [currentUserLocalTime]);
+    const timezoneName = useMemo(() => DateUtils.getZoneAbbreviation(currentUserLocalTime, props.timezone.selected), [currentUserLocalTime, props.timezone.selected]);
 
     useEffect(() => {
         // If the any of the props that getCurrentUserLocalTime depends on change, we want to update the displayed time immediately
@@ -68,7 +60,7 @@ function AutoUpdateTime(props) {
                 {props.translate('detailsPage.localTime')}
             </Text>
             <Text numberOfLines={1}>
-                {currentUserLocalTime.format('LT')} {timezoneName}
+                {DateUtils.formatToLocalTime(currentUserLocalTime)} {timezoneName}
             </Text>
         </View>
     );
diff --git a/src/components/ReportActionItem/ChronosOOOListActions.js b/src/components/ReportActionItem/ChronosOOOListActions.js
index 3c9c65d8f254..61c504d122ff 100644
--- a/src/components/ReportActionItem/ChronosOOOListActions.js
+++ b/src/components/ReportActionItem/ChronosOOOListActions.js
@@ -37,8 +37,8 @@ function ChronosOOOListActions(props) {
         <OfflineWithFeedback pendingAction={lodashGet(props.action, 'pendingAction', null)}>
             <View style={[styles.chatItemMessage]}>
                 {_.map(events, (event) => {
-                    const start = DateUtils.getLocalMomentFromDatetime(props.preferredLocale, lodashGet(event, 'start.date', ''));
-                    const end = DateUtils.getLocalMomentFromDatetime(props.preferredLocale, lodashGet(event, 'end.date', ''));
+                    const start = DateUtils.getLocalDateFromDatetime(props.preferredLocale, lodashGet(event, 'start.date', ''));
+                    const end = DateUtils.getLocalDateFromDatetime(props.preferredLocale, lodashGet(event, 'end.date', ''));
                     return (
                         <View
                             key={event.id}
@@ -49,12 +49,12 @@ function ChronosOOOListActions(props) {
                                     ? props.translate('chronos.oooEventSummaryFullDay', {
                                           summary: event.summary,
                                           dayCount: event.lengthInDays,
-                                          date: end.format('dddd LL'),
+                                          date: DateUtils.formatToLongDateWithWeekday(end),
                                       })
                                     : props.translate('chronos.oooEventSummaryPartialDay', {
                                           summary: event.summary,
-                                          timePeriod: `${start.format('LT')} - ${end.format('LT')}`,
-                                          date: end.format('dddd LL'),
+                                          timePeriod: `${DateUtils.formatToLocalTime(start)} - ${DateUtils.formatToLocalTime(end)}`,
+                                          date: DateUtils.formatToLongDateWithWeekday(end),
                                       })}
                             </Text>
                             <Button
diff --git a/src/libs/DateUtils.js b/src/libs/DateUtils.js
index 4115e8f1b9e3..0767bc44c002 100644
--- a/src/libs/DateUtils.js
+++ b/src/libs/DateUtils.js
@@ -1,8 +1,23 @@
-import moment from 'moment-timezone';
 import lodashGet from 'lodash/get';
-
-// IMPORTANT: load any locales (other than english) that might be passed to moment.locale()
-import 'moment/locale/es';
+import {zonedTimeToUtc, utcToZonedTime, formatInTimeZone} from 'date-fns-tz';
+import {es, enGB} from 'date-fns/locale';
+import {
+    formatDistanceToNow,
+    subMinutes,
+    isBefore,
+    subMilliseconds,
+    isToday,
+    isTomorrow,
+    isYesterday,
+    startOfWeek,
+    endOfWeek,
+    format,
+    setDefaultOptions,
+    endOfDay,
+    isSameDay,
+    isAfter,
+    isSameYear,
+} from 'date-fns';
 
 import _ from 'underscore';
 import Onyx from 'react-native-onyx';
@@ -32,25 +47,42 @@ Onyx.connect({
     },
 });
 
+/**
+ * Gets the locale string and setting default locale for date-fns
+ *
+ * @param {String} localeString
+ */
+function setLocale(localeString) {
+    switch (localeString) {
+        case CONST.LOCALES.EN:
+            setDefaultOptions({locale: enGB});
+            break;
+        case CONST.LOCALES.ES:
+            setDefaultOptions({locale: es});
+            break;
+        default:
+            break;
+    }
+}
+
 /**
  * Gets the user's stored time zone NVP and returns a localized
  * Moment object for the given ISO-formatted datetime string
  *
+ * @private
  * @param {String} locale
  * @param {String} datetime
  * @param {String} [currentSelectedTimezone]
- *
  * @returns  {Moment}
  *
- * @private
  */
-function getLocalMomentFromDatetime(locale, datetime, currentSelectedTimezone = timezone.selected) {
-    moment.locale(locale);
+function getLocalDateFromDatetime(locale, datetime, currentSelectedTimezone = timezone.selected) {
+    setLocale(locale);
     if (!datetime) {
-        return moment.tz(currentSelectedTimezone);
+        return utcToZonedTime(new Date(), currentSelectedTimezone);
     }
-
-    return moment.utc(datetime).tz(currentSelectedTimezone);
+    const parsedDatetime = new Date(`${datetime}Z`);
+    return utcToZonedTime(parsedDatetime, currentSelectedTimezone);
 }
 
 /**
@@ -66,32 +98,38 @@ function getLocalMomentFromDatetime(locale, datetime, currentSelectedTimezone =
  * @param {Boolean} includeTimeZone
  * @param {String} [currentSelectedTimezone]
  * @param {Boolean} isLowercase
- *
  * @returns {String}
  */
 function datetimeToCalendarTime(locale, datetime, includeTimeZone = false, currentSelectedTimezone, isLowercase = false) {
-    const date = getLocalMomentFromDatetime(locale, datetime, currentSelectedTimezone);
+    const date = getLocalDateFromDatetime(locale, datetime, currentSelectedTimezone);
     const tz = includeTimeZone ? ' [UTC]Z' : '';
-
     let todayAt = Localize.translate(locale, 'common.todayAt');
     let tomorrowAt = Localize.translate(locale, 'common.tomorrowAt');
     let yesterdayAt = Localize.translate(locale, 'common.yesterdayAt');
     const at = Localize.translate(locale, 'common.conjunctionAt');
 
+    const startOfCurrentWeek = startOfWeek(new Date(), {weekStartsOn: 1}); // Assuming Monday is the start of the week
+    const endOfCurrentWeek = endOfWeek(new Date(), {weekStartsOn: 1}); // Assuming Monday is the start of the week
+
     if (isLowercase) {
         todayAt = todayAt.toLowerCase();
         tomorrowAt = tomorrowAt.toLowerCase();
         yesterdayAt = yesterdayAt.toLowerCase();
     }
 
-    return moment(date).calendar({
-        sameDay: `[${todayAt}] LT${tz}`,
-        nextDay: `[${tomorrowAt}] LT${tz}`,
-        lastDay: `[${yesterdayAt}] LT${tz}`,
-        nextWeek: `MMM D [${at}] LT${tz}`,
-        lastWeek: `MMM D [${at}] LT${tz}`,
-        sameElse: `MMM D, YYYY [${at}] LT${tz}`,
-    });
+    if (isToday(date)) {
+        return `${todayAt} ${format(date, CONST.DATE.LOCAL_TIME_FORMAT)}${tz}`;
+    }
+    if (isTomorrow(date)) {
+        return `${tomorrowAt} ${format(date, CONST.DATE.LOCAL_TIME_FORMAT)}${tz}`;
+    }
+    if (isYesterday(date)) {
+        return `${yesterdayAt} ${format(date, CONST.DATE.LOCAL_TIME_FORMAT)}${tz}`;
+    }
+    if (date >= startOfCurrentWeek && date <= endOfCurrentWeek) {
+        return `${format(date, CONST.DATE.MONTH_DAY_ABBR_FORMAT)} ${at} ${format(date, CONST.DATE.LOCAL_TIME_FORMAT)}${tz}`;
+    }
+    return `${format(date, CONST.DATE.MONTH_DAY_YEAR_ABBR_FORMAT)} ${at} ${format(date, CONST.DATE.LOCAL_TIME_FORMAT)}${tz}`;
 }
 
 /**
@@ -109,20 +147,65 @@ function datetimeToCalendarTime(locale, datetime, includeTimeZone = false, curre
  *
  * @param {String} locale
  * @param {String} datetime
- *
  * @returns {String}
  */
 function datetimeToRelative(locale, datetime) {
-    const date = getLocalMomentFromDatetime(locale, datetime);
+    const date = getLocalDateFromDatetime(locale, datetime);
+    return formatDistanceToNow(date, {addSuffix: true});
+}
+
+/**
+ * Gets the zone abbreviation from the date
+ *
+ * e.g.
+ *
+ * PST
+ * EST
+ * GMT +07  -  For GMT timezone
+ *
+ * @param {String} datetime
+ * @param {String} selectedTimezone
+ * @returns {String}
+ */
+function getZoneAbbreviation(datetime, selectedTimezone) {
+    return formatInTimeZone(datetime, selectedTimezone, 'zzz');
+}
+
+/**
+ * Format date to a long date format with weekday
+ *
+ * @param {String} datetime
+ * @returns {String} Sunday, July 9, 2023
+ */
+function formatToLongDateWithWeekday(datetime) {
+    return format(new Date(datetime), CONST.DATE.LONG_DATE_FORMAT_WITH_WEEKDAY);
+}
+
+/**
+ * Format date to a weekday format
+ *
+ * @param {String} datetime
+ * @returns {String} Sunday
+ */
+function formatToDayOfWeek(datetime) {
+    return format(new Date(datetime), CONST.DATE.WEEKDAY_TIME_FORMAT);
+}
 
-    return moment(date).fromNow();
+/**
+ * Format date to a local time
+ *
+ * @param {String} datetime
+ * @returns {String} 2:30 PM
+ */
+function formatToLocalTime(datetime) {
+    return format(new Date(datetime), CONST.DATE.LOCAL_TIME_FORMAT);
 }
 
 /**
  * A throttled version of a function that updates the current date in Onyx store
  */
 const updateCurrentDate = _.throttle(() => {
-    const currentDate = moment().format('YYYY-MM-DD');
+    const currentDate = format(new Date(), CONST.DATE.FNS_FORMAT_STRING);
     CurrentDate.setCurrentDate(currentDate);
 }, 1000 * 60 * 60 * 3); // 3 hours
 
@@ -140,7 +223,7 @@ function startCurrentDateUpdater() {
  * @returns {Object}
  */
 function getCurrentTimezone() {
-    const currentTimezone = moment.tz.guess(true);
+    const currentTimezone = Intl.DateTimeFormat().resolvedOptions().timeZone;
     if (timezone.automatic && timezone.selected !== currentTimezone) {
         return {...timezone, selected: currentTimezone};
     }
@@ -148,17 +231,20 @@ function getCurrentTimezone() {
 }
 
 // Used to throttle updates to the timezone when necessary
-let lastUpdatedTimezoneTime = moment();
+let lastUpdatedTimezoneTime = new Date();
 
 /**
  * @returns {Boolean}
  */
 function canUpdateTimezone() {
-    return lastUpdatedTimezoneTime.isBefore(moment().subtract(5, 'minutes'));
+    const currentTime = new Date();
+    const fiveMinutesAgo = subMinutes(currentTime, 5);
+    // Compare the last updated time with five minutes ago
+    return isBefore(lastUpdatedTimezoneTime, fiveMinutesAgo);
 }
 
 function setTimezoneUpdated() {
-    lastUpdatedTimezoneTime = moment();
+    lastUpdatedTimezoneTime = new Date();
 }
 
 /**
@@ -174,7 +260,6 @@ function getMicroseconds() {
  * Returns the current time in milliseconds in the format expected by the database
  *
  * @param {String|Number} [timestamp]
- *
  * @returns {String}
  */
 function getDBTime(timestamp = '') {
@@ -188,7 +273,8 @@ function getDBTime(timestamp = '') {
  * @returns {String}
  */
 function subtractMillisecondsFromDateTime(dateTime, milliseconds) {
-    const newTimestamp = moment.utc(dateTime).subtract(milliseconds, 'milliseconds').valueOf();
+    const date = zonedTimeToUtc(dateTime, 'Etc/UTC');
+    const newTimestamp = subMilliseconds(date, milliseconds).valueOf();
     return getDBTime(newTimestamp);
 }
 
@@ -215,37 +301,41 @@ function getStatusUntilDate(inputDate) {
     if (!inputDate) return '';
     const {translateLocal} = Localize;
 
-    const input = moment(inputDate, 'YYYY-MM-DD HH:mm:ss');
-    const now = moment();
-    const endOfToday = moment().endOf('day').format('YYYY-MM-DD HH:mm:ss');
+    const input = new Date(inputDate);
+    const now = new Date();
+    const endOfToday = endOfDay(now);
 
     // If the date is equal to the end of today
-    if (input.isSame(endOfToday)) {
+    if (isSameDay(input, endOfToday)) {
         return translateLocal('statusPage.untilTomorrow');
     }
 
     // If it's a time on the same date
-    if (input.isSame(now, 'day')) {
-        return translateLocal('statusPage.untilTime', {time: input.format('hh:mm A')});
+    if (isSameDay(input, now)) {
+        return translateLocal('statusPage.untilTime', {time: format(input, CONST.DATE.LOCAL_TIME_FORMAT)});
     }
 
     // If it's further in the future than tomorrow but within the same year
-    if (input.isAfter(now) && input.isSame(now, 'year')) {
-        return translateLocal('statusPage.untilTime', {time: input.format('MM-DD hh:mm A')});
+    if (isAfter(input, now) && isSameYear(input, now)) {
+        return translateLocal('statusPage.untilTime', {time: format(input, `${CONST.DATE.SHORT_DATE_FORMAT} ${CONST.DATE.LOCAL_TIME_FORMAT}`)});
     }
 
     // If it's in another year
-    return translateLocal('statusPage.untilTime', {time: input.format('YYYY-MM-DD hh:mm A')});
+    return translateLocal('statusPage.untilTime', {time: format(input, `${CONST.DATE.FNS_FORMAT_STRING} ${CONST.DATE.LOCAL_TIME_FORMAT}`)});
 }
 
 /**
  * @namespace DateUtils
  */
 const DateUtils = {
+    formatToDayOfWeek,
+    formatToLongDateWithWeekday,
+    formatToLocalTime,
+    getZoneAbbreviation,
     datetimeToRelative,
     datetimeToCalendarTime,
     startCurrentDateUpdater,
-    getLocalMomentFromDatetime,
+    getLocalDateFromDatetime,
     getCurrentTimezone,
     canUpdateTimezone,
     setTimezoneUpdated,
diff --git a/src/pages/home/report/ParticipantLocalTime.js b/src/pages/home/report/ParticipantLocalTime.js
index e5ffa3c30364..058346287b11 100644
--- a/src/pages/home/report/ParticipantLocalTime.js
+++ b/src/pages/home/report/ParticipantLocalTime.js
@@ -18,15 +18,14 @@ const propTypes = {
 
 function getParticipantLocalTime(participant, preferredLocale) {
     const reportRecipientTimezone = lodashGet(participant, 'timezone', CONST.DEFAULT_TIME_ZONE);
-    const reportTimezone = DateUtils.getLocalMomentFromDatetime(preferredLocale, null, reportRecipientTimezone.selected);
-    const currentTimezone = DateUtils.getLocalMomentFromDatetime(preferredLocale);
-    const reportRecipientDay = reportTimezone.format('dddd');
-    const currentUserDay = currentTimezone.format('dddd');
-
+    const reportTimezone = DateUtils.getLocalDateFromDatetime(preferredLocale, null, reportRecipientTimezone.selected);
+    const currentTimezone = DateUtils.getLocalDateFromDatetime(preferredLocale);
+    const reportRecipientDay = DateUtils.formatToDayOfWeek(reportTimezone);
+    const currentUserDay = DateUtils.formatToDayOfWeek(currentTimezone);
     if (reportRecipientDay !== currentUserDay) {
-        return `${reportTimezone.format('LT')} ${reportRecipientDay}`;
+        return `${DateUtils.formatToLocalTime(reportTimezone)} ${reportRecipientDay}`;
     }
-    return `${reportTimezone.format('LT')}`;
+    return `${DateUtils.formatToLocalTime(reportTimezone)}`;
 }
 
 function ParticipantLocalTime(props) {
diff --git a/src/pages/settings/Profile/TimezoneSelectPage.js b/src/pages/settings/Profile/TimezoneSelectPage.js
index 1bed325c435a..6cdfa5f458b2 100644
--- a/src/pages/settings/Profile/TimezoneSelectPage.js
+++ b/src/pages/settings/Profile/TimezoneSelectPage.js
@@ -1,11 +1,11 @@
 import lodashGet from 'lodash/get';
 import React, {useState, useRef} from 'react';
 import _ from 'underscore';
-import moment from 'moment-timezone';
 import withCurrentUserPersonalDetails, {withCurrentUserPersonalDetailsPropTypes, withCurrentUserPersonalDetailsDefaultProps} from '../../../components/withCurrentUserPersonalDetails';
 import ScreenWrapper from '../../../components/ScreenWrapper';
 import HeaderWithBackButton from '../../../components/HeaderWithBackButton';
 import CONST from '../../../CONST';
+import TIMEZONES from '../../../TIMEZONES';
 import * as PersonalDetails from '../../../libs/actions/PersonalDetails';
 import Navigation from '../../../libs/Navigation/Navigation';
 import ROUTES from '../../../ROUTES';
@@ -37,7 +37,7 @@ function TimezoneSelectPage(props) {
     const {translate} = useLocalize();
     const timezone = getUserTimezone(props.currentUserPersonalDetails);
     const allTimezones = useRef(
-        _.chain(moment.tz.names())
+        _.chain(TIMEZONES)
             .filter((tz) => !tz.startsWith('Etc/GMT'))
             .map((text) => ({
                 text,
diff --git a/tests/unit/DateUtilsTest.js b/tests/unit/DateUtilsTest.js
index fe193ef150d5..42aeff67820c 100644
--- a/tests/unit/DateUtilsTest.js
+++ b/tests/unit/DateUtilsTest.js
@@ -1,5 +1,6 @@
-import moment from 'moment';
 import Onyx from 'react-native-onyx';
+import {format as tzFormat} from 'date-fns-tz';
+import {addMinutes, subHours, subMinutes, subSeconds, format, setMinutes, setHours, subDays, addDays} from 'date-fns';
 import CONST from '../../src/CONST';
 import DateUtils from '../../src/libs/DateUtils';
 import ONYXKEYS from '../../src/ONYXKEYS';
@@ -8,7 +9,6 @@ import waitForPromisesToResolve from '../utils/waitForPromisesToResolve';
 const LOCALE = CONST.LOCALES.EN;
 
 describe('DateUtils', () => {
-    let originalNow;
     beforeAll(() => {
         Onyx.init({
             keys: ONYXKEYS,
@@ -20,39 +20,53 @@ describe('DateUtils', () => {
         return waitForPromisesToResolve();
     });
 
-    beforeEach(() => {
-        originalNow = moment.now;
-    });
-
     afterEach(() => {
+        jest.useRealTimers();
         Onyx.clear();
-        moment.now = originalNow;
     });
 
     const datetime = '2022-11-07 00:00:00';
-    it('should return a moment object with the formatted datetime when calling getLocalMomentFromDatetime', () => {
-        const localMoment = DateUtils.getLocalMomentFromDatetime(LOCALE, datetime, 'America/Los_Angeles');
-        expect(moment.isMoment(localMoment)).toBe(true);
-        expect(moment(localMoment).format()).toEqual('2022-11-06T16:00:00-08:00');
+    const timezone = 'America/Los_Angeles';
+
+    it('getZoneAbbreviation should show zone abbreviation from the datetime', () => {
+        const zoneAbbreviation = DateUtils.getZoneAbbreviation(datetime, timezone);
+        expect(zoneAbbreviation).toBe('PST');
     });
 
-    it('should return a moment object when calling getLocalMomentFromDatetime with null instead of a datetime', () => {
-        const localMoment = DateUtils.getLocalMomentFromDatetime(LOCALE, null, 'America/Los_Angeles');
-        expect(moment.isMoment(localMoment)).toBe(true);
+    it('formatToLongDateWithWeekday should return a long date with a weekday', () => {
+        const formattedDate = DateUtils.formatToLongDateWithWeekday(datetime);
+        expect(formattedDate).toBe('Monday, November 7, 2022');
+    });
+
+    it('formatToDayOfWeek should return a weekday', () => {
+        const weekDay = DateUtils.formatToDayOfWeek(datetime);
+        expect(weekDay).toBe('Monday');
+    });
+    it('formatToLocalTime should return a date in a local format', () => {
+        const localTime = DateUtils.formatToLocalTime(datetime);
+        expect(localTime).toBe('12:00 AM');
+    });
+
+    it('should return a date object with the formatted datetime when calling getLocalDateFromDatetime', () => {
+        const localDate = DateUtils.getLocalDateFromDatetime(LOCALE, datetime, timezone);
+        expect(tzFormat(localDate, CONST.DATE.FNS_TIMEZONE_FORMAT_STRING, {timeZone: timezone})).toEqual('2022-11-06T16:00:00-08:00');
     });
 
     it('should return the date in calendar time when calling datetimeToCalendarTime', () => {
-        const today = moment.utc().set({hour: 14, minute: 32});
-        expect(DateUtils.datetimeToCalendarTime(LOCALE, today)).toBe('Today at 2:32 PM');
+        const today = setMinutes(setHours(new Date(), 14), 32);
+        expect(DateUtils.datetimeToCalendarTime(LOCALE, today)).toBe('Today at 02:32 PM');
+
+        const tomorrow = addDays(setMinutes(setHours(new Date(), 14), 32), 1);
+        expect(DateUtils.datetimeToCalendarTime(LOCALE, tomorrow)).toBe('Tomorrow at 02:32 PM');
 
-        const yesterday = moment.utc().subtract(1, 'days').set({hour: 7, minute: 43});
-        expect(DateUtils.datetimeToCalendarTime(LOCALE, yesterday)).toBe('Yesterday at 7:43 AM');
+        const yesterday = setMinutes(setHours(subDays(new Date(), 1), 7), 43);
+        expect(DateUtils.datetimeToCalendarTime(LOCALE, yesterday)).toBe('Yesterday at 07:43 AM');
 
-        const date = moment.utc('2022-11-05').set({hour: 10, minute: 17});
+        const date = setMinutes(setHours(new Date('2022-11-05'), 10), 17);
         expect(DateUtils.datetimeToCalendarTime(LOCALE, date)).toBe('Nov 5, 2022 at 10:17 AM');
 
-        const todayLowercaseDate = moment.utc().set({hour: 14, minute: 32});
-        expect(DateUtils.datetimeToCalendarTime(LOCALE, todayLowercaseDate, false, undefined, true)).toBe('today at 2:32 PM');
+        const todayLowercaseDate = setMinutes(setHours(new Date(), 14), 32);
+        expect(DateUtils.datetimeToCalendarTime(LOCALE, todayLowercaseDate, false, undefined, true)).toBe('today at 02:32 PM');
     });
 
     it('should update timezone if automatic and selected timezone do not match', () => {
@@ -82,28 +96,30 @@ describe('DateUtils', () => {
     });
 
     it('canUpdateTimezone should return true when lastUpdatedTimezoneTime is more than 5 minutes ago', () => {
-        const currentTime = moment().add(6, 'minutes');
-        moment.now = jest.fn(() => currentTime);
+        // Use fake timers to control the current time
+        jest.useFakeTimers('modern');
+        jest.setSystemTime(addMinutes(new Date(), 6));
         const isUpdateTimezoneAllowed = DateUtils.canUpdateTimezone();
         expect(isUpdateTimezoneAllowed).toBe(true);
     });
 
     it('canUpdateTimezone should return false when lastUpdatedTimezoneTime is less than 5 minutes ago', () => {
-        const currentTime = moment().add(4, 'minutes');
-        moment.now = jest.fn(() => currentTime);
+        // Use fake timers to control the current time
+        jest.useFakeTimers('modern');
+        jest.setSystemTime(addMinutes(new Date(), 4));
         const isUpdateTimezoneAllowed = DateUtils.canUpdateTimezone();
         expect(isUpdateTimezoneAllowed).toBe(false);
     });
 
     it('should return the date in calendar time when calling datetimeToRelative', () => {
-        const aFewSecondsAgo = moment().subtract(10, 'seconds');
-        expect(DateUtils.datetimeToRelative(LOCALE, aFewSecondsAgo)).toBe('a few seconds ago');
+        const aFewSecondsAgo = subSeconds(new Date(), 10);
+        expect(DateUtils.datetimeToRelative(LOCALE, aFewSecondsAgo)).toBe('less than a minute ago');
 
-        const aMinuteAgo = moment().subtract(1, 'minute');
-        expect(DateUtils.datetimeToRelative(LOCALE, aMinuteAgo)).toBe('a minute ago');
+        const aMinuteAgo = subMinutes(new Date(), 1);
+        expect(DateUtils.datetimeToRelative(LOCALE, aMinuteAgo)).toBe('1 minute ago');
 
-        const anHourAgo = moment().subtract(1, 'hour');
-        expect(DateUtils.datetimeToRelative(LOCALE, anHourAgo)).toBe('an hour ago');
+        const anHourAgo = subHours(new Date(), 1);
+        expect(DateUtils.datetimeToRelative(LOCALE, anHourAgo)).toBe('about 1 hour ago');
     });
 
     it('subtractMillisecondsFromDateTime should subtract milliseconds from a given date and time', () => {
@@ -111,28 +127,28 @@ describe('DateUtils', () => {
         const millisecondsToSubtract = 5000; // 5 seconds
         const expectedDateTime = '2023-07-18 10:29:55.000';
         const result = DateUtils.subtractMillisecondsFromDateTime(initialDateTime, millisecondsToSubtract);
-        expect(result.valueOf()).toBe(expectedDateTime);
+        expect(result).toBe(expectedDateTime);
     });
 
     describe('getDBTime', () => {
         it('should return the date in the format expected by the database', () => {
             const getDBTime = DateUtils.getDBTime();
-            expect(getDBTime).toBe(moment(getDBTime).format('YYYY-MM-DD HH:mm:ss.SSS'));
+            expect(getDBTime).toBe(format(new Date(getDBTime), CONST.DATE.FNS_DB_FORMAT_STRING));
         });
 
-        it('should represent the correct moment in utc when used with a standard datetime string', () => {
+        it('should represent the correct date in utc when used with a standard datetime string', () => {
             const timestamp = 'Mon Nov 21 2022 19:04:14 GMT-0800 (Pacific Standard Time)';
             const getDBTime = DateUtils.getDBTime(timestamp);
             expect(getDBTime).toBe('2022-11-22 03:04:14.000');
         });
 
-        it('should represent the correct moment in time when used with an ISO string', () => {
+        it('should represent the correct date in time when used with an ISO string', () => {
             const timestamp = '2022-11-22T03:08:04.326Z';
             const getDBTime = DateUtils.getDBTime(timestamp);
             expect(getDBTime).toBe('2022-11-22 03:08:04.326');
         });
 
-        it('should represent the correct moment in time when used with a unix timestamp', () => {
+        it('should represent the correct date in time when used with a unix timestamp', () => {
             const timestamp = 1669086850792;
             const getDBTime = DateUtils.getDBTime(timestamp);
             expect(getDBTime).toBe('2022-11-22 03:14:10.792');