diff --git a/tools/api-checker/config/gwt27_28userApi.conf b/tools/api-checker/config/gwt27_28userApi.conf
index 5af2a09..1ce0f43 100644
--- a/tools/api-checker/config/gwt27_28userApi.conf
+++ b/tools/api-checker/config/gwt27_28userApi.conf
@@ -179,3 +179,14 @@
 
 # Added Objects.requireNonNull(Object, Supplier)
 java.util.Objects::requireNonNull(Ljava/lang/Object;Ljava/lang/String;) OVERLOADED_METHOD_CALL
+
+# Added new Logger lazy logging methods
+java.util.logging.Logger::config(Ljava/lang/String;) OVERLOADED_METHOD_CALL
+java.util.logging.Logger::fine(Ljava/lang/String;) OVERLOADED_METHOD_CALL
+java.util.logging.Logger::finer(Ljava/lang/String;) OVERLOADED_METHOD_CALL
+java.util.logging.Logger::finest(Ljava/lang/String;) OVERLOADED_METHOD_CALL
+java.util.logging.Logger::info(Ljava/lang/String;) OVERLOADED_METHOD_CALL
+java.util.logging.Logger::log(Ljava/util/logging/Level;Ljava/lang/String;) OVERLOADED_METHOD_CALL
+java.util.logging.Logger::log(Ljava/util/logging/Level;Ljava/lang/String;Ljava/lang/Throwable;) OVERLOADED_METHOD_CALL
+java.util.logging.Logger::severe(Ljava/lang/String;) OVERLOADED_METHOD_CALL
+java.util.logging.Logger::warning(Ljava/lang/String;) OVERLOADED_METHOD_CALL
diff --git a/user/super/com/google/gwt/emul/java/util/logging/Logger.java b/user/super/com/google/gwt/emul/java/util/logging/Logger.java
index c0c7587..b391248 100644
--- a/user/super/com/google/gwt/emul/java/util/logging/Logger.java
+++ b/user/super/com/google/gwt/emul/java/util/logging/Logger.java
@@ -17,6 +17,7 @@
 
 import java.util.ArrayList;
 import java.util.List;
+import java.util.function.Supplier;
 
 /**
  *  An emulation of the java.util.logging.Logger class. See
@@ -87,6 +88,13 @@
     log(Level.CONFIG, msg);
   }
 
+  public void config(Supplier<String> msgSupplier) {
+    if (LOGGING_FALSE || LOGGING_SEVERE || LOGGING_WARNING) {
+      return;
+    }
+    log(Level.CONFIG, msgSupplier);
+  }
+
   public void fine(String msg) {
     if (LOGGING_FALSE || LOGGING_SEVERE || LOGGING_WARNING) {
       return;
@@ -94,6 +102,13 @@
     log(Level.FINE, msg);
   }
 
+  public void fine(Supplier<String> msgSupplier) {
+    if (LOGGING_FALSE || LOGGING_SEVERE || LOGGING_WARNING) {
+      return;
+    }
+    log(Level.FINE, msgSupplier);
+  }
+
   public void finer(String msg) {
     if (LOGGING_FALSE || LOGGING_SEVERE || LOGGING_WARNING) {
       return;
@@ -101,6 +116,13 @@
     log(Level.FINER, msg);
   }
 
+  public void finer(Supplier<String> msgSupplier) {
+    if (LOGGING_FALSE || LOGGING_SEVERE || LOGGING_WARNING) {
+      return;
+    }
+    log(Level.FINER, msgSupplier);
+  }
+
   public void finest(String msg) {
     if (LOGGING_FALSE || LOGGING_SEVERE || LOGGING_WARNING) {
       return;
@@ -108,6 +130,13 @@
     log(Level.FINEST, msg);
   }
 
+  public void finest(Supplier<String> msgSupplier) {
+    if (LOGGING_FALSE || LOGGING_SEVERE || LOGGING_WARNING) {
+      return;
+    }
+    log(Level.FINEST, msgSupplier);
+  }
+
   public void info(String msg) {
     if (LOGGING_FALSE || LOGGING_SEVERE || LOGGING_WARNING) {
       return;
@@ -115,6 +144,13 @@
     log(Level.INFO, msg);
   }
 
+  public void info(Supplier<String> msgSupplier) {
+    if (LOGGING_FALSE || LOGGING_SEVERE || LOGGING_WARNING) {
+      return;
+    }
+    log(Level.INFO, msgSupplier);
+  }
+
   public void warning(String msg) {
     if (LOGGING_FALSE || LOGGING_SEVERE) {
       return;
@@ -122,6 +158,13 @@
     log(Level.WARNING, msg);
   }
 
+  public void warning(Supplier<String> msgSupplier) {
+    if (LOGGING_FALSE || LOGGING_SEVERE) {
+      return;
+    }
+    log(Level.WARNING, msgSupplier);
+  }
+
   public void severe(String msg) {
     if (LOGGING_FALSE) {
       return;
@@ -129,6 +172,13 @@
     log(Level.SEVERE, msg);
   }
 
+  public void severe(Supplier<String> msgSupplier) {
+    if (LOGGING_FALSE) {
+      return;
+    }
+    log(Level.SEVERE, msgSupplier);
+  }
+
   public Handler[] getHandlers() {
     if (LOGGING_FALSE) {
       return new Handler[0];
@@ -154,44 +204,48 @@
   }
 
   public boolean isLoggable(Level messageLevel) {
-    return LOGGING_FALSE
-        ? false : getEffectiveLevel().intValue() <= messageLevel.intValue();
+    if (LOGGING_FALSE) {
+      return false;
+    } else if (LOGGING_SEVERE) {
+      return messageLevel.intValue() >= Level.SEVERE.intValue();
+    } else if (LOGGING_WARNING) {
+      return messageLevel.intValue() >= Level.WARNING.intValue();
+    } else {
+      return messageLevel.intValue() >= getEffectiveLevel().intValue();
+    }
   }
 
   public void log(Level level, String msg) {
     log(level, msg, null);
   }
 
+  public void log(Level level, Supplier<String> msgSupplier) {
+    log(level, null, msgSupplier);
+  }
+
   public void log(Level level, String msg, Throwable thrown) {
     if (LOGGING_FALSE) {
       return;
     }
-    if (LOGGING_SEVERE) {
-      if (level.intValue() >= 1000) {
-        actuallyLog(level, msg, thrown);
-      }
-    } else if (LOGGING_WARNING) {
-      if (level.intValue() >= Level.WARNING.intValue()) {
-        actuallyLog(level, msg, thrown);
-      }
-    } else {
+    if (isLoggable(level)) {
       actuallyLog(level, msg, thrown);
     }
   }
 
+  public void log(Level level, Throwable thrown, Supplier<String> msgSupplier) {
+    if (LOGGING_FALSE) {
+      return;
+    }
+    if (isLoggable(level)) {
+      actuallyLog(level, msgSupplier.get(), thrown);
+    }
+  }
+
   public void log(LogRecord record) {
     if (LOGGING_FALSE) {
       return;
     }
-    if (LOGGING_SEVERE) {
-      if (record.getLevel().intValue() >= 1000) {
-        actuallyLog(record);
-      }
-    } else if (LOGGING_WARNING) {
-      if (record.getLevel().intValue() >= Level.WARNING.intValue()) {
-        actuallyLog(record);
-      }
-    } else {
+    if (isLoggable(record.getLevel())) {
       actuallyLog(record);
     }
   }
@@ -243,26 +297,22 @@
   }
 
   private void actuallyLog(Level level, String msg, Throwable thrown) {
-    if (isLoggable(level)) {
-      LogRecord record = new LogRecord(level, msg);
-      record.setThrown(thrown);
-      record.setLoggerName(getName());
-      actuallyLog(record);
-    }
+    LogRecord record = new LogRecord(level, msg);
+    record.setThrown(thrown);
+    record.setLoggerName(getName());
+    actuallyLog(record);
   }
 
   private void actuallyLog(LogRecord record) {
-    if (isLoggable(record.getLevel())) {
-      for (Handler handler : getHandlers()) {
+    for (Handler handler : getHandlers()) {
+      handler.publish(record);
+    }
+    Logger logger = getUseParentHandlers() ? getParent() : null;
+    while (logger != null) {
+      for (Handler handler : logger.getHandlers()) {
         handler.publish(record);
       }
-      Logger logger = getUseParentHandlers() ? getParent() : null;
-      while (logger != null) {
-        for (Handler handler : logger.getHandlers()) {
-          handler.publish(record);
-        }
-        logger = logger.getUseParentHandlers() ? logger.getParent() : null;
-      }
+      logger = logger.getUseParentHandlers() ? logger.getParent() : null;
     }
   }