diff --git a/CHANGES.md b/CHANGES.md
index 4143f78d9..b42635b86 100644
--- a/CHANGES.md
+++ b/CHANGES.md
@@ -1,5 +1,6 @@
 # Changes
 
+
 ## [2.0.NEXT] - 2020-01-xx
 
 ### Changed
@@ -8,6 +9,8 @@
 
 * Skip empty chunks when returning response from a `Stream` #1308
 
+* Update the `time` dependency to 0.2.5
+
 ## [2.0.0] - 2019-12-25
 
 ### Changed
diff --git a/Cargo.toml b/Cargo.toml
index 9f0748e0c..a6783a6db 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -87,7 +87,7 @@ regex = "1.3"
 serde = { version = "1.0", features=["derive"] }
 serde_json = "1.0"
 serde_urlencoded = "0.6.1"
-time = "0.1.42"
+time = { version = "0.2.5", default-features = false, features = ["std"] }
 url = "2.1"
 open-ssl = { version="0.10", package = "openssl", optional = true }
 rust-tls = { version = "0.16.0", package = "rustls", optional = true }
diff --git a/actix-http/CHANGES.md b/actix-http/CHANGES.md
index ee3dae5d5..511ef4f1c 100644
--- a/actix-http/CHANGES.md
+++ b/actix-http/CHANGES.md
@@ -2,6 +2,10 @@
 
 # [Unreleased]
 
+### Changed
+
+* Update the `time` dependency to 0.2.5
+
 ### Fixed
 
 * Allow `SameSite=None` cookies to be sent in a response.
diff --git a/actix-http/Cargo.toml b/actix-http/Cargo.toml
index 93aaa756e..cd813e49f 100644
--- a/actix-http/Cargo.toml
+++ b/actix-http/Cargo.toml
@@ -52,7 +52,6 @@ base64 = "0.11"
 bitflags = "1.2"
 bytes = "0.5.3"
 copyless = "0.1.4"
-chrono = "0.4.6"
 derive_more = "0.99.2"
 either = "1.5.3"
 encoding_rs = "0.8"
@@ -77,7 +76,7 @@ serde_json = "1.0"
 sha-1 = "0.8"
 slab = "0.4"
 serde_urlencoded = "0.6.1"
-time = "0.1.42"
+time = { version = "0.2.5", default-features = false, features = ["std"] }
 
 # for secure cookie
 ring = { version = "0.16.9", optional = true }
diff --git a/actix-http/src/config.rs b/actix-http/src/config.rs
index be949aaef..50322bf20 100644
--- a/actix-http/src/config.rs
+++ b/actix-http/src/config.rs
@@ -7,7 +7,7 @@ use std::{fmt, net};
 use actix_rt::time::{delay_for, delay_until, Delay, Instant};
 use bytes::BytesMut;
 use futures_util::{future, FutureExt};
-use time;
+use time::OffsetDateTime;
 
 // "Sun, 06 Nov 1994 08:49:37 GMT".len()
 const DATE_VALUE_LENGTH: usize = 29;
@@ -211,7 +211,7 @@ impl Date {
     }
     fn update(&mut self) {
         self.pos = 0;
-        write!(self, "{}", time::at_utc(time::get_time()).rfc822()).unwrap();
+        write!(self, "{}", OffsetDateTime::now().format("%a, %d %b %Y %H:%M:%S GMT")).unwrap();
     }
 }
 
diff --git a/actix-http/src/cookie/builder.rs b/actix-http/src/cookie/builder.rs
index f99d02b02..c3820abf0 100644
--- a/actix-http/src/cookie/builder.rs
+++ b/actix-http/src/cookie/builder.rs
@@ -1,7 +1,6 @@
 use std::borrow::Cow;
 
-use chrono::Duration;
-use time::Tm;
+use time::{Duration, OffsetDateTime};
 
 use super::{Cookie, SameSite};
 
@@ -64,13 +63,13 @@ impl CookieBuilder {
     /// use actix_http::cookie::Cookie;
     ///
     /// let c = Cookie::build("foo", "bar")
-    ///     .expires(time::now())
+    ///     .expires(time::OffsetDateTime::now())
     ///     .finish();
     ///
     /// assert!(c.expires().is_some());
     /// ```
     #[inline]
-    pub fn expires(mut self, when: Tm) -> CookieBuilder {
+    pub fn expires(mut self, when: OffsetDateTime) -> CookieBuilder {
         self.cookie.set_expires(when);
         self
     }
@@ -108,7 +107,9 @@ impl CookieBuilder {
     /// ```
     #[inline]
     pub fn max_age_time(mut self, value: Duration) -> CookieBuilder {
-        self.cookie.set_max_age(value);
+        // Truncate any nanoseconds from the Duration, as they aren't represented within `Max-Age`
+        // and would cause two otherwise identical `Cookie` instances to not be equivalent to one another.
+        self.cookie.set_max_age(Duration::seconds(value.whole_seconds()));
         self
     }
 
@@ -212,7 +213,7 @@ impl CookieBuilder {
     ///
     /// ```rust
     /// use actix_http::cookie::Cookie;
-    /// use chrono::Duration;
+    /// use time::Duration;
     ///
     /// let c = Cookie::build("foo", "bar")
     ///     .permanent()
diff --git a/actix-http/src/cookie/jar.rs b/actix-http/src/cookie/jar.rs
index dc2de4dfe..64922897b 100644
--- a/actix-http/src/cookie/jar.rs
+++ b/actix-http/src/cookie/jar.rs
@@ -1,7 +1,7 @@
 use std::collections::HashSet;
 use std::mem::replace;
 
-use chrono::Duration;
+use time::{Duration, OffsetDateTime};
 
 use super::delta::DeltaCookie;
 use super::Cookie;
@@ -188,7 +188,7 @@ impl CookieJar {
     ///
     /// ```rust
     /// use actix_http::cookie::{CookieJar, Cookie};
-    /// use chrono::Duration;
+    /// use time::Duration;
     ///
     /// let mut jar = CookieJar::new();
     ///
@@ -202,7 +202,7 @@ impl CookieJar {
     /// let delta: Vec<_> = jar.delta().collect();
     /// assert_eq!(delta.len(), 1);
     /// assert_eq!(delta[0].name(), "name");
-    /// assert_eq!(delta[0].max_age(), Some(Duration::seconds(0)));
+    /// assert_eq!(delta[0].max_age(), Some(Duration::zero()));
     /// ```
     ///
     /// Removing a new cookie does not result in a _removal_ cookie:
@@ -220,8 +220,8 @@ impl CookieJar {
     pub fn remove(&mut self, mut cookie: Cookie<'static>) {
         if self.original_cookies.contains(cookie.name()) {
             cookie.set_value("");
-            cookie.set_max_age(Duration::seconds(0));
-            cookie.set_expires(time::now() - Duration::days(365));
+            cookie.set_max_age(Duration::zero());
+            cookie.set_expires(OffsetDateTime::now() - Duration::days(365));
             self.delta_cookies.replace(DeltaCookie::removed(cookie));
         } else {
             self.delta_cookies.remove(cookie.name());
@@ -239,7 +239,7 @@ impl CookieJar {
     ///
     /// ```rust
     /// use actix_http::cookie::{CookieJar, Cookie};
-    /// use chrono::Duration;
+    /// use time::Duration;
     ///
     /// let mut jar = CookieJar::new();
     ///
@@ -533,7 +533,7 @@ mod test {
     #[test]
     #[cfg(feature = "secure-cookies")]
     fn delta() {
-        use chrono::Duration;
+        use time::Duration;
         use std::collections::HashMap;
 
         let mut c = CookieJar::new();
@@ -556,7 +556,7 @@ mod test {
         assert!(names.get("test2").unwrap().is_none());
         assert!(names.get("test3").unwrap().is_none());
         assert!(names.get("test4").unwrap().is_none());
-        assert_eq!(names.get("original").unwrap(), &Some(Duration::seconds(0)));
+        assert_eq!(names.get("original").unwrap(), &Some(Duration::zero()));
     }
 
     #[test]
diff --git a/actix-http/src/cookie/mod.rs b/actix-http/src/cookie/mod.rs
index d9db600ea..09120e19f 100644
--- a/actix-http/src/cookie/mod.rs
+++ b/actix-http/src/cookie/mod.rs
@@ -65,9 +65,8 @@ use std::borrow::Cow;
 use std::fmt;
 use std::str::FromStr;
 
-use chrono::Duration;
 use percent_encoding::{percent_encode, AsciiSet, CONTROLS};
-use time::Tm;
+use time::{Duration, OffsetDateTime};
 
 pub use self::builder::CookieBuilder;
 pub use self::draft::*;
@@ -172,7 +171,7 @@ pub struct Cookie<'c> {
     /// The cookie's value.
     value: CookieStr,
     /// The cookie's expiration, if any.
-    expires: Option<Tm>,
+    expires: Option<OffsetDateTime>,
     /// The cookie's maximum age, if any.
     max_age: Option<Duration>,
     /// The cookie's domain, if any.
@@ -479,7 +478,7 @@ impl<'c> Cookie<'c> {
     /// assert_eq!(c.max_age(), None);
     ///
     /// let c = Cookie::parse("name=value; Max-Age=3600").unwrap();
-    /// assert_eq!(c.max_age().map(|age| age.num_hours()), Some(1));
+    /// assert_eq!(c.max_age().map(|age| age.whole_hours()), Some(1));
     /// ```
     #[inline]
     pub fn max_age(&self) -> Option<Duration> {
@@ -544,10 +543,10 @@ impl<'c> Cookie<'c> {
     /// let expire_time = "Wed, 21 Oct 2017 07:28:00 GMT";
     /// let cookie_str = format!("name=value; Expires={}", expire_time);
     /// let c = Cookie::parse(cookie_str).unwrap();
-    /// assert_eq!(c.expires().map(|t| t.tm_year), Some(117));
+    /// assert_eq!(c.expires().map(|t| t.year()), Some(2017));
     /// ```
     #[inline]
-    pub fn expires(&self) -> Option<Tm> {
+    pub fn expires(&self) -> Option<OffsetDateTime> {
         self.expires
     }
 
@@ -645,7 +644,7 @@ impl<'c> Cookie<'c> {
     ///
     /// ```rust
     /// use actix_http::cookie::Cookie;
-    /// use chrono::Duration;
+    /// use time::Duration;
     ///
     /// let mut c = Cookie::new("name", "value");
     /// assert_eq!(c.max_age(), None);
@@ -698,18 +697,19 @@ impl<'c> Cookie<'c> {
     ///
     /// ```rust
     /// use actix_http::cookie::Cookie;
+    /// use time::{Duration, OffsetDateTime};
     ///
     /// let mut c = Cookie::new("name", "value");
     /// assert_eq!(c.expires(), None);
     ///
-    /// let mut now = time::now();
-    /// now.tm_year += 1;
+    /// let mut now = OffsetDateTime::now();
+    /// now += Duration::week();
     ///
     /// c.set_expires(now);
     /// assert!(c.expires().is_some())
     /// ```
     #[inline]
-    pub fn set_expires(&mut self, time: Tm) {
+    pub fn set_expires(&mut self, time: OffsetDateTime) {
         self.expires = Some(time);
     }
 
@@ -720,7 +720,7 @@ impl<'c> Cookie<'c> {
     ///
     /// ```rust
     /// use actix_http::cookie::Cookie;
-    /// use chrono::Duration;
+    /// use time::Duration;
     ///
     /// let mut c = Cookie::new("foo", "bar");
     /// assert!(c.expires().is_none());
@@ -733,7 +733,7 @@ impl<'c> Cookie<'c> {
     pub fn make_permanent(&mut self) {
         let twenty_years = Duration::days(365 * 20);
         self.set_max_age(twenty_years);
-        self.set_expires(time::now() + twenty_years);
+        self.set_expires(OffsetDateTime::now() + twenty_years);
     }
 
     fn fmt_parameters(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
@@ -758,11 +758,11 @@ impl<'c> Cookie<'c> {
         }
 
         if let Some(max_age) = self.max_age() {
-            write!(f, "; Max-Age={}", max_age.num_seconds())?;
+            write!(f, "; Max-Age={}", max_age.whole_seconds())?;
         }
 
         if let Some(time) = self.expires() {
-            write!(f, "; Expires={}", time.rfc822())?;
+            write!(f, "; Expires={}", time.format("%a, %d %b %Y %H:%M:%S GMT"))?;
         }
 
         Ok(())
@@ -990,7 +990,7 @@ impl<'a, 'b> PartialEq<Cookie<'b>> for Cookie<'a> {
 #[cfg(test)]
 mod tests {
     use super::{Cookie, SameSite};
-    use time::strptime;
+    use time::{offset, PrimitiveDateTime};
 
     #[test]
     fn format() {
@@ -1015,7 +1015,7 @@ mod tests {
         assert_eq!(&cookie.to_string(), "foo=bar; Domain=www.rust-lang.org");
 
         let time_str = "Wed, 21 Oct 2015 07:28:00 GMT";
-        let expires = strptime(time_str, "%a, %d %b %Y %H:%M:%S %Z").unwrap();
+        let expires = PrimitiveDateTime::parse(time_str, "%a, %d %b %Y %H:%M:%S").unwrap().using_offset(offset!(UTC));
         let cookie = Cookie::build("foo", "bar").expires(expires).finish();
         assert_eq!(
             &cookie.to_string(),
diff --git a/actix-http/src/cookie/parse.rs b/actix-http/src/cookie/parse.rs
index 20aee9507..28eb4f8b6 100644
--- a/actix-http/src/cookie/parse.rs
+++ b/actix-http/src/cookie/parse.rs
@@ -5,11 +5,13 @@ use std::error::Error;
 use std::fmt;
 use std::str::Utf8Error;
 
-use chrono::Duration;
 use percent_encoding::percent_decode;
+use time::{Duration, offset};
 
 use super::{Cookie, CookieStr, SameSite};
 
+use crate::time_parser;
+
 /// Enum corresponding to a parsing error.
 #[derive(Debug, PartialEq, Eq, Clone, Copy)]
 pub enum ParseError {
@@ -147,7 +149,7 @@ fn parse_inner<'c>(s: &str, decode: bool) -> Result<Cookie<'c>, ParseError> {
                     Ok(val) => {
                         // Don't panic if the max age seconds is greater than what's supported by
                         // `Duration`.
-                        let val = cmp::min(val, Duration::max_value().num_seconds());
+                        let val = cmp::min(val, Duration::max_value().whole_seconds());
                         Some(Duration::seconds(val))
                     }
                     Err(_) => continue,
@@ -179,16 +181,14 @@ fn parse_inner<'c>(s: &str, decode: bool) -> Result<Cookie<'c>, ParseError> {
                 }
             }
             ("expires", Some(v)) => {
-                // Try strptime with three date formats according to
+                // Try parsing with three date formats according to
                 // http://tools.ietf.org/html/rfc2616#section-3.3.1. Try
                 // additional ones as encountered in the real world.
-                let tm = time::strptime(v, "%a, %d %b %Y %H:%M:%S %Z")
-                    .or_else(|_| time::strptime(v, "%A, %d-%b-%y %H:%M:%S %Z"))
-                    .or_else(|_| time::strptime(v, "%a, %d-%b-%Y %H:%M:%S %Z"))
-                    .or_else(|_| time::strptime(v, "%a %b %d %H:%M:%S %Y"));
+                let tm = time_parser::parse_http_date(v)
+                    .or_else(|| time::parse(v, "%a, %d-%b-%Y %H:%M:%S").ok());
 
-                if let Ok(time) = tm {
-                    cookie.expires = Some(time)
+                if let Some(time) = tm {
+                    cookie.expires = Some(time.using_offset(offset!(UTC)))
                 }
             }
             _ => {
@@ -216,8 +216,7 @@ where
 #[cfg(test)]
 mod tests {
     use super::{Cookie, SameSite};
-    use chrono::Duration;
-    use time::strptime;
+    use time::{offset, Duration, PrimitiveDateTime};
 
     macro_rules! assert_eq_parse {
         ($string:expr, $expected:expr) => {
@@ -377,7 +376,7 @@ mod tests {
         );
 
         let time_str = "Wed, 21 Oct 2015 07:28:00 GMT";
-        let expires = strptime(time_str, "%a, %d %b %Y %H:%M:%S %Z").unwrap();
+        let expires = PrimitiveDateTime::parse(time_str, "%a, %d %b %Y %H:%M:%S").unwrap().using_offset(offset!(UTC));
         expected.set_expires(expires);
         assert_eq_parse!(
             " foo=bar ;HttpOnly; Secure; Max-Age=4; Path=/foo; \
@@ -386,7 +385,7 @@ mod tests {
         );
 
         unexpected.set_domain("foo.com");
-        let bad_expires = strptime(time_str, "%a, %d %b %Y %H:%S:%M %Z").unwrap();
+        let bad_expires = PrimitiveDateTime::parse(time_str, "%a, %d %b %Y %H:%S:%M").unwrap().using_offset(offset!(UTC));
         expected.set_expires(bad_expires);
         assert_ne_parse!(
             " foo=bar ;HttpOnly; Secure; Max-Age=4; Path=/foo; \
@@ -414,8 +413,9 @@ mod tests {
 
     #[test]
     fn do_not_panic_on_large_max_ages() {
-        let max_seconds = Duration::max_value().num_seconds();
-        let expected = Cookie::build("foo", "bar").max_age(max_seconds).finish();
-        assert_eq_parse!(format!(" foo=bar; Max-Age={:?}", max_seconds + 1), expected);
+        let max_duration = Duration::max_value();
+        let expected = Cookie::build("foo", "bar").max_age_time(max_duration).finish();
+        let overflow_duration = max_duration.checked_add(Duration::nanoseconds(1)).unwrap_or(max_duration);
+        assert_eq_parse!(format!(" foo=bar; Max-Age={:?}", overflow_duration.whole_seconds()), expected);
     }
 }
diff --git a/actix-http/src/header/shared/httpdate.rs b/actix-http/src/header/shared/httpdate.rs
index 28d6a25ec..1b52f0de4 100644
--- a/actix-http/src/header/shared/httpdate.rs
+++ b/actix-http/src/header/shared/httpdate.rs
@@ -1,59 +1,46 @@
 use std::fmt::{self, Display};
 use std::io::Write;
 use std::str::FromStr;
-use std::time::{Duration, SystemTime, UNIX_EPOCH};
+use std::time::{SystemTime, UNIX_EPOCH};
 
 use bytes::{buf::BufMutExt, BytesMut};
 use http::header::{HeaderValue, InvalidHeaderValue};
+use time::{PrimitiveDateTime, OffsetDateTime, offset};
 
 use crate::error::ParseError;
 use crate::header::IntoHeaderValue;
+use crate::time_parser;
 
 /// A timestamp with HTTP formatting and parsing
 #[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord)]
-pub struct HttpDate(time::Tm);
+pub struct HttpDate(OffsetDateTime);
 
 impl FromStr for HttpDate {
     type Err = ParseError;
 
     fn from_str(s: &str) -> Result<HttpDate, ParseError> {
-        match time::strptime(s, "%a, %d %b %Y %T %Z")
-            .or_else(|_| time::strptime(s, "%A, %d-%b-%y %T %Z"))
-            .or_else(|_| time::strptime(s, "%c"))
-        {
-            Ok(t) => Ok(HttpDate(t)),
-            Err(_) => Err(ParseError::Header),
+        match time_parser::parse_http_date(s) {
+            Some(t) => Ok(HttpDate(t.using_offset(offset!(UTC)))),
+            None => Err(ParseError::Header)
         }
     }
 }
 
 impl Display for HttpDate {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        fmt::Display::fmt(&self.0.to_utc().rfc822(), f)
+        fmt::Display::fmt(&self.0.format("%a, %d %b %Y %H:%M:%S GMT"), f)
     }
 }
 
-impl From<time::Tm> for HttpDate {
-    fn from(tm: time::Tm) -> HttpDate {
-        HttpDate(tm)
+impl From<OffsetDateTime> for HttpDate {
+    fn from(dt: OffsetDateTime) -> HttpDate {
+        HttpDate(dt)
     }
 }
 
 impl From<SystemTime> for HttpDate {
     fn from(sys: SystemTime) -> HttpDate {
-        let tmspec = match sys.duration_since(UNIX_EPOCH) {
-            Ok(dur) => {
-                time::Timespec::new(dur.as_secs() as i64, dur.subsec_nanos() as i32)
-            }
-            Err(err) => {
-                let neg = err.duration();
-                time::Timespec::new(
-                    -(neg.as_secs() as i64),
-                    -(neg.subsec_nanos() as i32),
-                )
-            }
-        };
-        HttpDate(time::at_utc(tmspec))
+        HttpDate(PrimitiveDateTime::from(sys).using_offset(offset!(UTC)))
     }
 }
 
@@ -62,56 +49,45 @@ impl IntoHeaderValue for HttpDate {
 
     fn try_into(self) -> Result<HeaderValue, Self::Error> {
         let mut wrt = BytesMut::with_capacity(29).writer();
-        write!(wrt, "{}", self.0.rfc822()).unwrap();
+        write!(wrt, "{}", self.0.to_offset(offset!(UTC)).format("%a, %d %b %Y %H:%M:%S GMT")).unwrap();
         HeaderValue::from_maybe_shared(wrt.get_mut().split().freeze())
     }
 }
 
 impl From<HttpDate> for SystemTime {
     fn from(date: HttpDate) -> SystemTime {
-        let spec = date.0.to_timespec();
-        if spec.sec >= 0 {
-            UNIX_EPOCH + Duration::new(spec.sec as u64, spec.nsec as u32)
-        } else {
-            UNIX_EPOCH - Duration::new(spec.sec as u64, spec.nsec as u32)
-        }
+        let dt = date.0;
+        let epoch = OffsetDateTime::unix_epoch();
+
+        UNIX_EPOCH + (dt - epoch)
     }
 }
 
 #[cfg(test)]
 mod tests {
     use super::HttpDate;
-    use time::Tm;
-
-    const NOV_07: HttpDate = HttpDate(Tm {
-        tm_nsec: 0,
-        tm_sec: 37,
-        tm_min: 48,
-        tm_hour: 8,
-        tm_mday: 7,
-        tm_mon: 10,
-        tm_year: 94,
-        tm_wday: 0,
-        tm_isdst: 0,
-        tm_yday: 0,
-        tm_utcoff: 0,
-    });
+    use time::{PrimitiveDateTime, date, time, offset};
 
     #[test]
     fn test_date() {
+        let nov_07 = HttpDate(PrimitiveDateTime::new(
+            date!(1994-11-07),
+            time!(8:48:37)
+        ).using_offset(offset!(UTC)));
+
         assert_eq!(
             "Sun, 07 Nov 1994 08:48:37 GMT".parse::<HttpDate>().unwrap(),
-            NOV_07
+            nov_07
         );
         assert_eq!(
             "Sunday, 07-Nov-94 08:48:37 GMT"
                 .parse::<HttpDate>()
                 .unwrap(),
-            NOV_07
+            nov_07
         );
         assert_eq!(
             "Sun Nov  7 08:48:37 1994".parse::<HttpDate>().unwrap(),
-            NOV_07
+            nov_07
         );
         assert!("this-is-no-date".parse::<HttpDate>().is_err());
     }
diff --git a/actix-http/src/lib.rs b/actix-http/src/lib.rs
index 7a47012f8..a5ae4b447 100644
--- a/actix-http/src/lib.rs
+++ b/actix-http/src/lib.rs
@@ -27,6 +27,7 @@ mod payload;
 mod request;
 mod response;
 mod service;
+mod time_parser;
 
 pub mod cookie;
 pub mod error;
diff --git a/actix-http/src/time_parser.rs b/actix-http/src/time_parser.rs
new file mode 100644
index 000000000..f6623d24e
--- /dev/null
+++ b/actix-http/src/time_parser.rs
@@ -0,0 +1,42 @@
+use time::{PrimitiveDateTime, Date};
+
+/// Attempt to parse a `time` string as one of either RFC 1123, RFC 850, or asctime.
+pub fn parse_http_date(time: &str) -> Option<PrimitiveDateTime> {
+    try_parse_rfc_1123(time)
+        .or_else(|| try_parse_rfc_850(time))
+        .or_else(|| try_parse_asctime(time))
+}
+
+/// Attempt to parse a `time` string as a RFC 1123 formatted date time string.
+fn try_parse_rfc_1123(time: &str) -> Option<PrimitiveDateTime> {
+    time::parse(time, "%a, %d %b %Y %H:%M:%S").ok()
+}
+
+/// Attempt to parse a `time` string as a RFC 850 formatted date time string.
+fn try_parse_rfc_850(time: &str) -> Option<PrimitiveDateTime> {
+    match PrimitiveDateTime::parse(time, "%A, %d-%b-%y %H:%M:%S") {
+        Ok(dt) => {
+            // If the `time` string contains a two-digit year, then as per RFC 2616 § 19.3,
+            // we consider the year as part of this century if it's within the next 50 years,
+            // otherwise we consider as part of the previous century.
+            let now = PrimitiveDateTime::now();
+            let century_start_year = (now.year() / 100) * 100;
+            let mut expanded_year = century_start_year + dt.year();
+
+            if expanded_year > now.year() + 50 {
+                expanded_year -= 100;
+            }
+
+            match Date::try_from_ymd(expanded_year, dt.month(), dt.day()) {
+                Ok(date) => Some(PrimitiveDateTime::new(date, dt.time())),
+                Err(_) => None
+            }
+        }
+        Err(_) => None
+    }
+}
+
+/// Attempt to parse a `time` string using ANSI C's `asctime` format.
+fn try_parse_asctime(time: &str) -> Option<PrimitiveDateTime> {
+    time::parse(time, "%a %b %_d %H:%M:%S %Y").ok()
+}
diff --git a/actix-identity/CHANGES.md b/actix-identity/CHANGES.md
index 594c21388..0c9809ea1 100644
--- a/actix-identity/CHANGES.md
+++ b/actix-identity/CHANGES.md
@@ -1,5 +1,9 @@
 # Changes
 
+## [Unreleased] - 2020-xx-xx
+
+* Update the `time` dependency to 0.2.5
+
 ## [0.2.1] - 2020-01-10
 
 * Fix panic with already borrowed: BorrowMutError #1263
diff --git a/actix-identity/Cargo.toml b/actix-identity/Cargo.toml
index 8cd6b1271..efeb24bda 100644
--- a/actix-identity/Cargo.toml
+++ b/actix-identity/Cargo.toml
@@ -21,9 +21,9 @@ actix-service = "1.0.2"
 futures = "0.3.1"
 serde = "1.0"
 serde_json = "1.0"
-time = "0.1.42"
+time = { version = "0.2.5", default-features = false, features = ["std"] }
 
 [dev-dependencies]
 actix-rt = "1.0.0"
 actix-http = "1.0.1"
-bytes = "0.5.3"
\ No newline at end of file
+bytes = "0.5.3"
diff --git a/actix-identity/src/lib.rs b/actix-identity/src/lib.rs
index 3b9626991..b584b1af7 100644
--- a/actix-identity/src/lib.rs
+++ b/actix-identity/src/lib.rs
@@ -428,14 +428,14 @@ impl CookieIdentityInner {
         let now = SystemTime::now();
         if let Some(visit_deadline) = self.visit_deadline {
             if now.duration_since(value.visit_timestamp?).ok()?
-                > visit_deadline.to_std().ok()?
+                > visit_deadline
             {
                 return None;
             }
         }
         if let Some(login_deadline) = self.login_deadline {
             if now.duration_since(value.login_timestamp?).ok()?
-                > login_deadline.to_std().ok()?
+                > login_deadline
             {
                 return None;
             }
@@ -855,7 +855,7 @@ mod tests {
         let cv: CookieValue = serde_json::from_str(cookie.value()).unwrap();
         assert_eq!(cv.identity, identity);
         let now = SystemTime::now();
-        let t30sec_ago = now - Duration::seconds(30).to_std().unwrap();
+        let t30sec_ago = now - Duration::seconds(30);
         match login_timestamp {
             LoginTimestampCheck::NoTimestamp => assert_eq!(cv.login_timestamp, None),
             LoginTimestampCheck::NewTimestamp => assert!(
@@ -997,7 +997,7 @@ mod tests {
             create_identity_server(|c| c.login_deadline(Duration::days(90))).await;
         let cookie = login_cookie(
             COOKIE_LOGIN,
-            Some(SystemTime::now() - Duration::days(180).to_std().unwrap()),
+            Some(SystemTime::now() - Duration::days(180)),
             None,
         );
         let mut resp = test::call_service(
@@ -1023,7 +1023,7 @@ mod tests {
         let cookie = login_cookie(
             COOKIE_LOGIN,
             None,
-            Some(SystemTime::now() - Duration::days(180).to_std().unwrap()),
+            Some(SystemTime::now() - Duration::days(180)),
         );
         let mut resp = test::call_service(
             &mut srv,
@@ -1065,7 +1065,7 @@ mod tests {
                 .login_deadline(Duration::days(90))
         })
         .await;
-        let timestamp = SystemTime::now() - Duration::days(1).to_std().unwrap();
+        let timestamp = SystemTime::now() - Duration::days(1);
         let cookie = login_cookie(COOKIE_LOGIN, Some(timestamp), Some(timestamp));
         let mut resp = test::call_service(
             &mut srv,
diff --git a/actix-multipart/CHANGES.md b/actix-multipart/CHANGES.md
index 31f326d05..d73a69393 100644
--- a/actix-multipart/CHANGES.md
+++ b/actix-multipart/CHANGES.md
@@ -1,5 +1,9 @@
 # Changes
 
+## [0.2.1] - 2020-01-xx
+
+* Remove the unused `time` dependency
+
 ## [0.2.0] - 2019-12-20
 
 * Release
@@ -44,4 +48,4 @@
 
 * Split multipart support to separate crate
 
-* Optimize multipart handling #634, #769
\ No newline at end of file
+* Optimize multipart handling #634, #769
diff --git a/actix-multipart/Cargo.toml b/actix-multipart/Cargo.toml
index 6c683cb1a..f9cd7cfd2 100644
--- a/actix-multipart/Cargo.toml
+++ b/actix-multipart/Cargo.toml
@@ -25,9 +25,8 @@ httparse = "1.3"
 futures = "0.3.1"
 log = "0.4"
 mime = "0.3"
-time = "0.1"
 twoway = "0.2"
 
 [dev-dependencies]
 actix-rt = "1.0.0"
-actix-http = "1.0.0"
\ No newline at end of file
+actix-http = "1.0.0"
diff --git a/actix-session/CHANGES.md b/actix-session/CHANGES.md
index e4306fa9d..f2c1a5c0b 100644
--- a/actix-session/CHANGES.md
+++ b/actix-session/CHANGES.md
@@ -1,5 +1,9 @@
 # Changes
 
+## [Unreleased] - 2020-01-xx
+
+* Update the `time` dependency to 0.2.5
+
 ## [0.3.0] - 2019-12-20
 
 * Release
diff --git a/actix-session/Cargo.toml b/actix-session/Cargo.toml
index 5989cc0d6..b279c9d89 100644
--- a/actix-session/Cargo.toml
+++ b/actix-session/Cargo.toml
@@ -29,7 +29,7 @@ derive_more = "0.99.2"
 futures = "0.3.1"
 serde = "1.0"
 serde_json = "1.0"
-time = "0.1.42"
+time = { version = "0.2.5", default-features = false, features = ["std"] }
 
 [dev-dependencies]
 actix-rt = "1.0.0"
diff --git a/actix-session/src/cookie.rs b/actix-session/src/cookie.rs
index 75eef0c01..bc0262935 100644
--- a/actix-session/src/cookie.rs
+++ b/actix-session/src/cookie.rs
@@ -27,6 +27,7 @@ use actix_web::{Error, HttpMessage, ResponseError};
 use derive_more::{Display, From};
 use futures::future::{ok, FutureExt, LocalBoxFuture, Ready};
 use serde_json::error::Error as JsonError;
+use time::{Duration, OffsetDateTime};
 
 use crate::{Session, SessionStatus};
 
@@ -56,7 +57,7 @@ struct CookieSessionInner {
     domain: Option<String>,
     secure: bool,
     http_only: bool,
-    max_age: Option<time::Duration>,
+    max_age: Option<Duration>,
     same_site: Option<SameSite>,
 }
 
@@ -123,8 +124,8 @@ impl CookieSessionInner {
     fn remove_cookie<B>(&self, res: &mut ServiceResponse<B>) -> Result<(), Error> {
         let mut cookie = Cookie::named(self.name.clone());
         cookie.set_value("");
-        cookie.set_max_age(time::Duration::seconds(0));
-        cookie.set_expires(time::now() - time::Duration::days(365));
+        cookie.set_max_age(Duration::zero());
+        cookie.set_expires(OffsetDateTime::now() - Duration::days(365));
 
         let val = HeaderValue::from_str(&cookie.to_string())?;
         res.headers_mut().append(SET_COOKIE, val);
@@ -263,7 +264,7 @@ impl CookieSession {
 
     /// Sets the `max-age` field in the session cookie being built.
     pub fn max_age(self, seconds: i64) -> CookieSession {
-        self.max_age_time(time::Duration::seconds(seconds))
+        self.max_age_time(Duration::seconds(seconds))
     }
 
     /// Sets the `max-age` field in the session cookie being built.
diff --git a/src/middleware/logger.rs b/src/middleware/logger.rs
index 97fa7463f..d692132ce 100644
--- a/src/middleware/logger.rs
+++ b/src/middleware/logger.rs
@@ -14,7 +14,7 @@ use bytes::Bytes;
 use futures::future::{ok, Ready};
 use log::debug;
 use regex::Regex;
-use time;
+use time::OffsetDateTime;
 
 use crate::dev::{BodySize, MessageBody, ResponseBody};
 use crate::error::{Error, Result};
@@ -163,11 +163,11 @@ where
             LoggerResponse {
                 fut: self.service.call(req),
                 format: None,
-                time: time::now(),
+                time: OffsetDateTime::now(),
                 _t: PhantomData,
             }
         } else {
-            let now = time::now();
+            let now = OffsetDateTime::now();
             let mut format = self.inner.format.clone();
 
             for unit in &mut format.0 {
@@ -192,7 +192,7 @@ where
 {
     #[pin]
     fut: S::Future,
-    time: time::Tm,
+    time: OffsetDateTime,
     format: Option<Format>,
     _t: PhantomData<(B,)>,
 }
@@ -242,7 +242,7 @@ pub struct StreamLog<B> {
     body: ResponseBody<B>,
     format: Option<Format>,
     size: usize,
-    time: time::Tm,
+    time: OffsetDateTime,
 }
 
 impl<B> Drop for StreamLog<B> {
@@ -366,20 +366,20 @@ impl FormatText {
         &self,
         fmt: &mut Formatter<'_>,
         size: usize,
-        entry_time: time::Tm,
+        entry_time: OffsetDateTime,
     ) -> Result<(), fmt::Error> {
         match *self {
             FormatText::Str(ref string) => fmt.write_str(string),
             FormatText::Percent => "%".fmt(fmt),
             FormatText::ResponseSize => size.fmt(fmt),
             FormatText::Time => {
-                let rt = time::now() - entry_time;
-                let rt = (rt.num_nanoseconds().unwrap_or(0) as f64) / 1_000_000_000.0;
+                let rt = OffsetDateTime::now() - entry_time;
+                let rt = rt.as_seconds_f64();
                 fmt.write_fmt(format_args!("{:.6}", rt))
             }
             FormatText::TimeMillis => {
-                let rt = time::now() - entry_time;
-                let rt = (rt.num_nanoseconds().unwrap_or(0) as f64) / 1_000_000.0;
+                let rt = OffsetDateTime::now() - entry_time;
+                let rt = (rt.whole_nanoseconds() as f64) / 1_000_000.0;
                 fmt.write_fmt(format_args!("{:.6}", rt))
             }
             FormatText::EnvironHeader(ref name) => {
@@ -414,7 +414,7 @@ impl FormatText {
         }
     }
 
-    fn render_request(&mut self, now: time::Tm, req: &ServiceRequest) {
+    fn render_request(&mut self, now: OffsetDateTime, req: &ServiceRequest) {
         match *self {
             FormatText::RequestLine => {
                 *self = if req.query_string().is_empty() {
@@ -436,7 +436,7 @@ impl FormatText {
             }
             FormatText::UrlPath => *self = FormatText::Str(req.path().to_string()),
             FormatText::RequestTime => {
-                *self = FormatText::Str(now.rfc3339().to_string())
+                *self = FormatText::Str(now.format("%Y-%m-%dT%H:%M:%S"))
             }
             FormatText::RequestHeader(ref name) => {
                 let s = if let Some(val) = req.headers().get(name) {
@@ -513,7 +513,7 @@ mod tests {
         .uri("/test/route/yeah")
         .to_srv_request();
 
-        let now = time::now();
+        let now = OffsetDateTime::now();
         for unit in &mut format.0 {
             unit.render_request(now, &req);
         }
@@ -544,7 +544,7 @@ mod tests {
         )
         .to_srv_request();
 
-        let now = time::now();
+        let now = OffsetDateTime::now();
         for unit in &mut format.0 {
             unit.render_request(now, &req);
         }
@@ -554,7 +554,7 @@ mod tests {
             unit.render_response(&resp);
         }
 
-        let entry_time = time::now();
+        let entry_time = OffsetDateTime::now();
         let render = |fmt: &mut Formatter<'_>| {
             for unit in &format.0 {
                 unit.render(fmt, 1024, entry_time)?;
@@ -572,7 +572,7 @@ mod tests {
         let mut format = Format::new("%t");
         let req = TestRequest::default().to_srv_request();
 
-        let now = time::now();
+        let now = OffsetDateTime::now();
         for unit in &mut format.0 {
             unit.render_request(now, &req);
         }
@@ -589,6 +589,6 @@ mod tests {
             Ok(())
         };
         let s = format!("{}", FormatDisplay(&render));
-        assert!(s.contains(&format!("{}", now.rfc3339())));
+        assert!(s.contains(&format!("{}", now.format("%Y-%m-%dT%H:%M:%S"))));
     }
 }
diff --git a/test-server/CHANGES.md b/test-server/CHANGES.md
index 5690afc64..617b8092f 100644
--- a/test-server/CHANGES.md
+++ b/test-server/CHANGES.md
@@ -1,5 +1,10 @@
 # Changes
 
+## [Unreleased] - 2020-xx-xx
+
+* Update the `time` dependency to 0.2.5
+
+
 ## [1.0.0] - 2019-12-13
 
 ### Changed
diff --git a/test-server/Cargo.toml b/test-server/Cargo.toml
index 52a2da8da..b22414e29 100644
--- a/test-server/Cargo.toml
+++ b/test-server/Cargo.toml
@@ -51,7 +51,7 @@ serde_json = "1.0"
 sha1 = "0.6"
 slab = "0.4"
 serde_urlencoded = "0.6.1"
-time = "0.1"
+time = { version = "0.2.5", default-features = false, features = ["std"] }
 open-ssl = { version="0.10", package="openssl", optional = true }
 
 [dev-dependencies]