diff --git a/jOOQ-meta/src/main/java/org/jooq/util/BufferedLog.java b/jOOQ-meta/src/main/java/org/jooq/util/BufferedLog.java
index eaadc300f6..e879268e26 100644
--- a/jOOQ-meta/src/main/java/org/jooq/util/BufferedLog.java
+++ b/jOOQ-meta/src/main/java/org/jooq/util/BufferedLog.java
@@ -206,11 +206,6 @@ public class BufferedLog implements Log {
         // messages.add(message(INFO, message, details, throwable));
     }
 
-    @Override
-    public boolean isWarnEnabled() {
-        return delegate.isWarnEnabled();
-    }
-
     @Override
     public void warn(Object message) {
         delegate.warn(message);
@@ -235,11 +230,6 @@ public class BufferedLog implements Log {
         messages.add(message(WARN, message, details, throwable));
     }
 
-    @Override
-    public boolean isErrorEnabled() {
-        return delegate.isErrorEnabled();
-    }
-
     @Override
     public void error(Object message) {
         delegate.error(message);
diff --git a/jOOQ/src/main/java/org/jooq/Log.java b/jOOQ/src/main/java/org/jooq/Log.java
index 196a5ec684..6860af74a6 100644
--- a/jOOQ/src/main/java/org/jooq/Log.java
+++ b/jOOQ/src/main/java/org/jooq/Log.java
@@ -161,11 +161,6 @@ public interface Log {
      */
     void info(Object message, Object details, Throwable throwable);
 
-    /**
-     * Check if <code>WARN</code> level logging is enabled.
-     */
-    boolean isWarnEnabled();
-
     /**
      * Log a message in <code>WARN</code> level.
      *
@@ -200,11 +195,6 @@ public interface Log {
      */
     void warn(Object message, Object details, Throwable throwable);
 
-    /**
-     * Check if <code>ERROR</code> level logging is enabled.
-     */
-    boolean isErrorEnabled();
-
     /**
      * Log a message in <code>ERROR</code> level.
      *
@@ -239,84 +229,6 @@ public interface Log {
      */
     void error(Object message, Object details, Throwable throwable);
 
-    default boolean isEnabled(final Log.Level level) {
-        switch (level) {
-            case TRACE: return isTraceEnabled();
-            case DEBUG: return isDebugEnabled();
-            case INFO: return isInfoEnabled();
-            case WARN: return isWarnEnabled();
-            case ERROR: return isErrorEnabled();
-            case FATAL: return isErrorEnabled();
-            default: return false;
-        }
-    }
-
-    default void log(final Object message, final Log.Level level) {
-        log(message, (Object) null, level);
-    }
-
-    default void log(final Object message, final Object details, final Log.Level level) {
-        switch (level) {
-            case TRACE: {
-                trace(message, details);
-                return;
-            }
-            case DEBUG: {
-                debug(message, details);
-                return;
-            }
-            case INFO: {
-                info(message, details);
-                return;
-            }
-            case WARN: {
-                warn(message, details);
-                return;
-            }
-            case ERROR: {
-                error(message, details);
-                return;
-            }
-            case FATAL: {
-                error(message, details);
-                return;
-            }
-        }
-    }
-
-    default void log(final Object message, final Throwable throwable, final Log.Level level) {
-        log(message, null, throwable, level);
-    }
-
-    default void log(final Object message, final Object details, final Throwable throwable, final Log.Level level) {
-        switch (level) {
-            case TRACE: {
-                trace(message, details, throwable);
-                return;
-            }
-            case DEBUG: {
-                debug(message, details, throwable);
-                return;
-            }
-            case INFO: {
-                info(message, details, throwable);
-                return;
-            }
-            case WARN: {
-                warn(message, details, throwable);
-                return;
-            }
-            case ERROR: {
-                error(message, details, throwable);
-                return;
-            }
-            case FATAL: {
-                error(message, details, throwable);
-                return;
-            }
-        }
-    }
-
     /**
      * The log level.
      */
diff --git a/jOOQ/src/main/java/org/jooq/conf/Settings.java b/jOOQ/src/main/java/org/jooq/conf/Settings.java
index b954dd289e..d41402a6bc 100644
--- a/jOOQ/src/main/java/org/jooq/conf/Settings.java
+++ b/jOOQ/src/main/java/org/jooq/conf/Settings.java
@@ -8,8 +8,6 @@
 
 package org.jooq.conf;
 
-import org.jooq.Log;
-
 import java.io.Serializable;
 import javax.xml.bind.annotation.XmlAccessType;
 import javax.xml.bind.annotation.XmlAccessorType;
@@ -67,22 +65,6 @@ public class Settings
     protected StatementType statementType = StatementType.PREPARED_STATEMENT;
     @XmlElement(defaultValue = "true")
     protected Boolean executeLogging = true;
-    @XmlElement(defaultValue = "DEBUG")
-    protected Log.Level executeLoggingBindVariables = Log.Level.DEBUG;
-    @XmlElement(defaultValue = "false")
-    protected Boolean executeLoggingAbbreviatedBindVariables = false;
-    @XmlElement(defaultValue = "DEBUG")
-    protected Log.Level executeLoggingSqlString = Log.Level.DEBUG;
-    @XmlElement(defaultValue = "DEBUG")
-    protected Log.Level executeLoggingResult = Log.Level.DEBUG;
-    @XmlElement(defaultValue = "5")
-    protected Integer executeLoggingResultNumberOfRows = 5;
-    @XmlElement(defaultValue = "50")
-    protected Integer executeLoggingResultNumberOfColumns = 50;
-    @XmlElement(defaultValue = "DEBUG")
-    protected Log.Level executeLoggingRoutine = Log.Level.DEBUG;
-    @XmlElement(defaultValue = "DEBUG")
-    protected Log.Level executeLoggingException = Log.Level.DEBUG;
     @XmlElement(defaultValue = "false")
     protected Boolean executeWithOptimisticLocking = false;
     @XmlElement(defaultValue = "false")
@@ -474,70 +456,6 @@ public class Settings
         this.executeLogging = value;
     }
 
-    public Log.Level getExecuteLoggingBindVariables() {
-        return executeLoggingBindVariables;
-    }
-
-    public void setExecuteLoggingBindVariables(final Log.Level executeLoggingBindVariables) {
-        this.executeLoggingBindVariables = executeLoggingBindVariables;
-    }
-
-    public Boolean isExecuteLoggingAbbreviatedBindVariables() {
-        return executeLoggingAbbreviatedBindVariables;
-    }
-
-    public void setExecuteLoggingAbbreviatedBindVariables(final Boolean executeLoggingAbbreviatedBindVariables) {
-        this.executeLoggingAbbreviatedBindVariables = executeLoggingAbbreviatedBindVariables;
-    }
-
-    public Log.Level getExecuteLoggingSqlString() {
-        return executeLoggingSqlString;
-    }
-
-    public void setExecuteLoggingSqlString(final Log.Level executeLoggingSqlString) {
-        this.executeLoggingSqlString = executeLoggingSqlString;
-    }
-
-    public Log.Level getExecuteLoggingResult() {
-        return executeLoggingResult;
-    }
-
-    public void setExecuteLoggingResult(final Log.Level executeLoggingResult) {
-        this.executeLoggingResult = executeLoggingResult;
-    }
-
-    public Integer getExecuteLoggingResultNumberOfRows() {
-        return executeLoggingResultNumberOfRows;
-    }
-
-    public void setExecuteLoggingResultNumberOfRows(final Integer executeLoggingResultNumberOfRows) {
-        this.executeLoggingResultNumberOfRows = executeLoggingResultNumberOfRows;
-    }
-
-    public Integer getExecuteLoggingResultNumberOfColumns() {
-        return executeLoggingResultNumberOfColumns;
-    }
-
-    public void setExecuteLoggingResultNumberOfColumns(final Integer executeLoggingResultNumberOfColumns) {
-        this.executeLoggingResultNumberOfColumns = executeLoggingResultNumberOfColumns;
-    }
-
-    public Log.Level getExecuteLoggingRoutine() {
-        return executeLoggingRoutine;
-    }
-
-    public void setExecuteLoggingRoutine(final Log.Level executeLoggingRoutine) {
-        this.executeLoggingRoutine = executeLoggingRoutine;
-    }
-
-    public Log.Level getExecuteLoggingException() {
-        return executeLoggingException;
-    }
-
-    public void setExecuteLoggingException(final Log.Level executeLoggingException) {
-        this.executeLoggingException = executeLoggingException;
-    }
-
     /**
      * Whether store() and delete() methods should be executed with optimistic locking.
      *
@@ -1193,55 +1111,6 @@ public class Settings
         return this;
     }
 
-    public Settings withExecuteLoggingBindVariables(Log.Level value) {
-        setExecuteLoggingBindVariables(value);
-        return this;
-    }
-
-    public Settings withExecuteLoggingAbbreviatedBindVariables(Boolean value) {
-        setExecuteLoggingAbbreviatedBindVariables(value);
-        return this;
-    }
-
-    public Settings withExecuteLoggingSqlString(Log.Level value) {
-        setExecuteLoggingSqlString(value);
-        return this;
-    }
-
-    public Settings withExecuteLoggingResult(Log.Level value) {
-        setExecuteLoggingResult(value);
-        return this;
-    }
-
-    public Settings withExecuteLoggingResultNumberOfRows(Integer value) {
-        setExecuteLoggingResultNumberOfRows(value);
-        return this;
-    }
-
-    public Settings withExecuteLoggingResultNumberOfColumns(Integer value) {
-        setExecuteLoggingResultNumberOfColumns(value);
-        return this;
-    }
-
-    public Settings withExecuteLoggingRoutine(Log.Level value) {
-        setExecuteLoggingRoutine(value);
-        return this;
-    }
-
-    public Settings withExecuteLoggingException(Log.Level value) {
-        setExecuteLoggingException(value);
-        return this;
-    }
-
-    public Settings withExecuteLoggingOverallLevel(Log.Level value) {
-        setExecuteLoggingBindVariables(value);
-        setExecuteLoggingSqlString(value);
-        setExecuteLoggingResult(value);
-        setExecuteLoggingRoutine(value);
-        setExecuteLoggingException(value);
-        return this;
-    }
-
     public Settings withExecuteWithOptimisticLocking(Boolean value) {
         setExecuteWithOptimisticLocking(value);
         return this;
@@ -1430,46 +1299,6 @@ public class Settings
             sb.append(executeLogging);
             sb.append("</executeLogging>");
         }
-        if (executeLoggingBindVariables!= null) {
-            sb.append("<executeLoggingBindVariables>");
-            sb.append(executeLoggingBindVariables);
-            sb.append("</executeLoggingBindVariables>");
-        }
-        if (executeLoggingAbbreviatedBindVariables!= null) {
-            sb.append("<executeLoggingAbbreviatedBindVariables>");
-            sb.append(executeLoggingAbbreviatedBindVariables);
-            sb.append("</executeLoggingAbbreviatedBindVariables>");
-        }
-        if (executeLoggingSqlString!= null) {
-            sb.append("<executeLoggingSqlString>");
-            sb.append(executeLoggingSqlString);
-            sb.append("</executeLoggingSqlString>");
-        }
-        if (executeLoggingResult!= null) {
-            sb.append("<executeLoggingResult>");
-            sb.append(executeLoggingResult);
-            sb.append("</executeLoggingResult>");
-        }
-        if (executeLoggingResultNumberOfRows!= null) {
-            sb.append("<executeLoggingResultNumberOfRows>");
-            sb.append(executeLoggingResultNumberOfRows);
-            sb.append("</executeLoggingResultNumberOfRows>");
-        }
-        if (executeLoggingResultNumberOfColumns!= null) {
-            sb.append("<executeLoggingResultNumberOfColumns>");
-            sb.append(executeLoggingResultNumberOfColumns);
-            sb.append("</executeLoggingResultNumberOfColumns>");
-        }
-        if (executeLoggingRoutine!= null) {
-            sb.append("<executeLoggingRoutine>");
-            sb.append(executeLoggingRoutine);
-            sb.append("</executeLoggingRoutine>");
-        }
-        if (executeLoggingException!= null) {
-            sb.append("<executeLoggingException>");
-            sb.append(executeLoggingException);
-            sb.append("</executeLoggingException>");
-        }
         if (executeWithOptimisticLocking!= null) {
             sb.append("<executeWithOptimisticLocking>");
             sb.append(executeWithOptimisticLocking);
@@ -1722,78 +1551,6 @@ public class Settings
                 return false;
             }
         }
-        if (executeLoggingBindVariables == null) {
-            if (other.executeLoggingBindVariables!= null) {
-                return false;
-            }
-        } else {
-            if (!executeLoggingBindVariables.equals(other.executeLoggingBindVariables)) {
-                return false;
-            }
-        }
-        if (executeLoggingAbbreviatedBindVariables == null) {
-            if (other.executeLoggingAbbreviatedBindVariables!= null) {
-                return false;
-            }
-        } else {
-            if (!executeLoggingAbbreviatedBindVariables.equals(other.executeLoggingAbbreviatedBindVariables)) {
-                return false;
-            }
-        }
-        if (executeLoggingSqlString == null) {
-            if (other.executeLoggingSqlString!= null) {
-                return false;
-            }
-        } else {
-            if (!executeLoggingSqlString.equals(other.executeLoggingSqlString)) {
-                return false;
-            }
-        }
-        if (executeLoggingResult == null) {
-            if (other.executeLoggingResult!= null) {
-                return false;
-            }
-        } else {
-            if (!executeLoggingResult.equals(other.executeLoggingResult)) {
-                return false;
-            }
-        }
-        if (executeLoggingResultNumberOfRows == null) {
-            if (other.executeLoggingResultNumberOfRows!= null) {
-                return false;
-            }
-        } else {
-            if (!executeLoggingResultNumberOfRows.equals(other.executeLoggingResultNumberOfRows)) {
-                return false;
-            }
-        }
-        if (executeLoggingResultNumberOfColumns == null) {
-            if (other.executeLoggingResultNumberOfColumns!= null) {
-                return false;
-            }
-        } else {
-            if (!executeLoggingResultNumberOfColumns.equals(other.executeLoggingResultNumberOfColumns)) {
-                return false;
-            }
-        }
-        if (executeLoggingRoutine == null) {
-            if (other.executeLoggingRoutine!= null) {
-                return false;
-            }
-        } else {
-            if (!executeLoggingRoutine.equals(other.executeLoggingRoutine)) {
-                return false;
-            }
-        }
-        if (executeLoggingException == null) {
-            if (other.executeLoggingException!= null) {
-                return false;
-            }
-        } else {
-            if (!executeLoggingException.equals(other.executeLoggingException)) {
-                return false;
-            }
-        }
         if (executeWithOptimisticLocking == null) {
             if (other.executeWithOptimisticLocking!= null) {
                 return false;
@@ -2030,14 +1787,6 @@ public class Settings
         result = ((prime*result)+((paramCastMode == null)? 0 :paramCastMode.hashCode()));
         result = ((prime*result)+((statementType == null)? 0 :statementType.hashCode()));
         result = ((prime*result)+((executeLogging == null)? 0 :executeLogging.hashCode()));
-        result = ((prime*result)+((executeLoggingBindVariables == null)? 0 :executeLoggingBindVariables.hashCode()));
-        result = ((prime*result)+((executeLoggingAbbreviatedBindVariables == null)? 0 :executeLoggingAbbreviatedBindVariables.hashCode()));
-        result = ((prime*result)+((executeLoggingSqlString == null)? 0 :executeLoggingSqlString.hashCode()));
-        result = ((prime*result)+((executeLoggingResult == null)? 0 :executeLoggingResult.hashCode()));
-        result = ((prime*result)+((executeLoggingResultNumberOfRows == null)? 0 :executeLoggingResultNumberOfRows.hashCode()));
-        result = ((prime*result)+((executeLoggingResultNumberOfColumns == null)? 0 :executeLoggingResultNumberOfColumns.hashCode()));
-        result = ((prime*result)+((executeLoggingRoutine == null)? 0 :executeLoggingRoutine.hashCode()));
-        result = ((prime*result)+((executeLoggingException == null)? 0 :executeLoggingException.hashCode()));
         result = ((prime*result)+((executeWithOptimisticLocking == null)? 0 :executeWithOptimisticLocking.hashCode()));
         result = ((prime*result)+((executeWithOptimisticLockingExcludeUnversioned == null)? 0 :executeWithOptimisticLockingExcludeUnversioned.hashCode()));
         result = ((prime*result)+((attachRecords == null)? 0 :attachRecords.hashCode()));
diff --git a/jOOQ/src/main/java/org/jooq/impl/ExecuteListeners.java b/jOOQ/src/main/java/org/jooq/impl/ExecuteListeners.java
index 416f60bd4d..68224cddaf 100644
--- a/jOOQ/src/main/java/org/jooq/impl/ExecuteListeners.java
+++ b/jOOQ/src/main/java/org/jooq/impl/ExecuteListeners.java
@@ -102,15 +102,7 @@ final class ExecuteListeners implements ExecuteListener {
             // [#6747] Avoid allocating the listener (and by consequence, the ExecuteListeners) if
             //         we do not DEBUG log anyway.
             if (LOGGER_LISTENER_LOGGER.isDebugEnabled())
-                (result = init(result)).add(new LoggerListener(
-                        ctx.settings().getExecuteLoggingBindVariables(),
-                        ctx.settings().isExecuteLoggingAbbreviatedBindVariables(),
-                        ctx.settings().getExecuteLoggingSqlString(),
-                        ctx.settings().getExecuteLoggingResult(),
-                        ctx.settings().getExecuteLoggingResultNumberOfRows(),
-                        ctx.settings().getExecuteLoggingResultNumberOfColumns(),
-                        ctx.settings().getExecuteLoggingRoutine(),
-                        ctx.settings().getExecuteLoggingException()));
+                (result = init(result)).add(new LoggerListener());
         }
 
         for (ExecuteListenerProvider provider : ctx.configuration().executeListenerProviders())
diff --git a/jOOQ/src/main/java/org/jooq/tools/JooqLogger.java b/jOOQ/src/main/java/org/jooq/tools/JooqLogger.java
index 7a077054c7..8071e9ba73 100644
--- a/jOOQ/src/main/java/org/jooq/tools/JooqLogger.java
+++ b/jOOQ/src/main/java/org/jooq/tools/JooqLogger.java
@@ -37,7 +37,6 @@
  */
 package org.jooq.tools;
 
-import org.apache.log4j.Priority;
 import org.jooq.Log;
 
 /**
@@ -93,16 +92,6 @@ public final class JooqLogger implements Log {
      */
     private boolean                   supportsInfo    = true;
 
-    /**
-     * Whether calls to {@link #warn(Object)} are possible.
-     */
-    private boolean                   supportsWarn   = true;
-
-    /**
-     * Whether calls to {@link #error(Object)} are possible.
-     */
-    private boolean                   supportsError    = true;
-
     /**
      * Get a logger wrapper for a class.
      */
@@ -130,20 +119,6 @@ public final class JooqLogger implements Log {
         // unavailable, e.g. because client code isn't using the latest version
         // of log4j or any other logger
 
-        try {
-            result.isErrorEnabled();
-        }
-        catch (Throwable e) {
-            result.supportsError = false;
-        }
-
-        try {
-            result.isWarnEnabled();
-        }
-        catch (Throwable e) {
-            result.supportsWarn = false;
-        }
-
         try {
             result.isInfoEnabled();
         }
@@ -399,23 +374,6 @@ public final class JooqLogger implements Log {
             util.log(java.util.logging.Level.INFO, "" + getMessage(message, details), throwable);
     }
 
-    /**
-     * Check if <code>WARN</code> level logging is enabled.
-     */
-    @Override
-    public boolean isWarnEnabled() {
-        if (!globalThreshold.supports(Log.Level.WARN))
-            return false;
-        if (!supportsWarn)
-            return false;
-        else if (slf4j != null)
-            return slf4j.isWarnEnabled();
-        else if (log4j != null)
-            return log4j.isEnabledFor(Priority.WARN);
-        else
-            return util.isLoggable(java.util.logging.Level.WARNING);
-    }
-
     /**
      * Log a message in <code>WARN</code> level.
      *
@@ -476,23 +434,6 @@ public final class JooqLogger implements Log {
             util.log(java.util.logging.Level.WARNING, "" + getMessage(message, details), throwable);
     }
 
-    /**
-     * Check if <code>ERROR</code> level logging is enabled.
-     */
-    @Override
-    public boolean isErrorEnabled() {
-        if (!globalThreshold.supports(Log.Level.ERROR))
-            return false;
-        if (!supportsError)
-            return false;
-        else if (slf4j != null)
-            return slf4j.isErrorEnabled();
-        else if (log4j != null)
-            return log4j.isEnabledFor(Priority.ERROR);
-        else
-            return util.isLoggable(java.util.logging.Level.SEVERE);
-    }
-
     /**
      * Log a message in <code>ERROR</code> level.
      *
diff --git a/jOOQ/src/main/java/org/jooq/tools/LoggerListener.java b/jOOQ/src/main/java/org/jooq/tools/LoggerListener.java
index 52edeac14f..c7845132bc 100644
--- a/jOOQ/src/main/java/org/jooq/tools/LoggerListener.java
+++ b/jOOQ/src/main/java/org/jooq/tools/LoggerListener.java
@@ -38,7 +38,6 @@
 package org.jooq.tools;
 
 import static java.lang.Boolean.TRUE;
-import static java.util.Objects.requireNonNull;
 import static org.jooq.impl.DSL.field;
 import static org.jooq.impl.DSL.name;
 import static org.jooq.impl.DSL.val;
@@ -54,7 +53,6 @@ import org.jooq.ExecuteContext;
 import org.jooq.ExecuteListener;
 import org.jooq.ExecuteType;
 import org.jooq.Field;
-import org.jooq.Log;
 import org.jooq.Param;
 import org.jooq.Parameter;
 import org.jooq.QueryPart;
@@ -84,121 +82,91 @@ public class LoggerListener extends DefaultExecuteListener {
 
     private static final JooqLogger log   = JooqLogger.getLogger(LoggerListener.class);
 
-    private final Log.Level executeLoggingBindVariables;
-
-    private final boolean   executeLoggingAbbreviatedBindVariables;
-
-    private final Log.Level executeLoggingSqlString;
-
-    private final Log.Level executeLoggingResult;
-
-    private final int       executeLoggingResultNumberOfRows;
-
-    private final int       executeLoggingResultNumberOfColumns;
-
-    private final Log.Level executeLoggingRoutine;
-
-    private final Log.Level executeLoggingException;
-
-    public LoggerListener(final Log.Level executeLoggingBindVariables,
-                          final Boolean executeLoggingAbbreviatedBindVariables,
-                          final Log.Level executeLoggingSqlString,
-                          final Log.Level executeLoggingResult,
-                          final Integer executeLoggingResultNumberOfRows,
-                          final Integer executeLoggingResultNumberOfColumns,
-                          final Log.Level executeLoggingRoutine,
-                          final Log.Level executeLoggingException) {
-        this.executeLoggingBindVariables = requireNonNull(executeLoggingBindVariables);
-        this.executeLoggingAbbreviatedBindVariables = requireNonNull(executeLoggingAbbreviatedBindVariables);
-        this.executeLoggingSqlString = requireNonNull(executeLoggingSqlString);
-        this.executeLoggingResult = requireNonNull(executeLoggingResult);
-        this.executeLoggingResultNumberOfRows = requireNonNull(executeLoggingResultNumberOfRows);
-        this.executeLoggingResultNumberOfColumns = requireNonNull(executeLoggingResultNumberOfColumns);
-        this.executeLoggingRoutine = requireNonNull(executeLoggingRoutine);
-        this.executeLoggingException = requireNonNull(executeLoggingException);
-    }
-
     @Override
     public void renderEnd(ExecuteContext ctx) {
-        Configuration configuration = ctx.configuration();
-        String newline = TRUE.equals(configuration.settings().isRenderFormatted()) ? "\n" : "";
+        if (log.isDebugEnabled()) {
+            Configuration configuration = ctx.configuration();
+            String newline = TRUE.equals(configuration.settings().isRenderFormatted()) ? "\n" : "";
 
-        // [#2939] Prevent excessive logging of bind variables only in DEBUG mode, not in TRACE mode.
-        if (executeLoggingAbbreviatedBindVariables)
-            configuration = abbreviateBindVariables(configuration);
+            // [#2939] Prevent excessive logging of bind variables only in DEBUG mode, not in TRACE mode.
+            if (!log.isTraceEnabled())
+                configuration = abbreviateBindVariables(configuration);
 
-        String[] batchSQL = ctx.batchSQL();
-        if (log.isEnabled(executeLoggingSqlString) && ctx.query() != null) {
+            String[] batchSQL = ctx.batchSQL();
+            if (ctx.query() != null) {
 
-            // Actual SQL passed to JDBC
-            log.log("Executing query", newline + ctx.sql(), executeLoggingSqlString);
+                // Actual SQL passed to JDBC
+                log.debug("Executing query", newline + ctx.sql());
 
-            // [#1278] DEBUG log also SQL with inlined bind values, if
-            // that is not the same as the actual SQL passed to JDBC
-            if (log.isEnabled(executeLoggingBindVariables)) {
+                // [#1278] DEBUG log also SQL with inlined bind values, if
+                // that is not the same as the actual SQL passed to JDBC
                 String inlined = DSL.using(configuration).renderInlined(ctx.query());
                 if (!ctx.sql().equals(inlined))
-                    log.log("-> with bind values", newline + inlined, executeLoggingBindVariables);
+                    log.debug("-> with bind values", newline + inlined);
             }
-        }
 
-        // [#2987] Log routines
-        else if (log.isEnabled(executeLoggingRoutine) && ctx.routine() != null) {
+            // [#2987] Log routines
+            else if (ctx.routine() != null) {
+                log.debug("Calling routine", newline + ctx.sql());
 
-            log.log("Calling routine", newline + ctx.sql(), executeLoggingRoutine);
-
-            if (log.isEnabled(executeLoggingBindVariables)) {
                 String inlined = DSL.using(configuration)
-                        .renderInlined(ctx.routine());
+                                    .renderInlined(ctx.routine());
 
                 if (!ctx.sql().equals(inlined))
-                    log.log("-> with bind values", newline + inlined, executeLoggingBindVariables);
+                    log.debug("-> with bind values", newline + inlined);
             }
-        } else if (log.isEnabled(executeLoggingSqlString) && !StringUtils.isBlank(ctx.sql())) {
 
-            // [#1529] Batch queries should be logged specially
-            if (ctx.type() == ExecuteType.BATCH)
-                log.log("Executing batch query", newline + ctx.sql(), executeLoggingSqlString);
-            else
-                log.log("Executing query", newline + ctx.sql(), executeLoggingSqlString);
-        }
+            else if (!StringUtils.isBlank(ctx.sql())) {
 
-        // [#2532] Log a complete BatchMultiple query
-        else if (log.isEnabled(executeLoggingSqlString) && batchSQL.length > 0) {
-            if (batchSQL[batchSQL.length - 1] != null)
-                for (String sql : batchSQL)
-                    log.log("Executing batch query", newline + sql, executeLoggingSqlString);
+                // [#1529] Batch queries should be logged specially
+                if (ctx.type() == ExecuteType.BATCH)
+                    log.debug("Executing batch query", newline + ctx.sql());
+                else
+                    log.debug("Executing query", newline + ctx.sql());
+            }
+
+            // [#2532] Log a complete BatchMultiple query
+            else if (batchSQL.length > 0) {
+                if (batchSQL[batchSQL.length - 1] != null)
+                    for (String sql : batchSQL)
+                        log.debug("Executing batch query", newline + sql);
+            }
         }
     }
 
     @Override
     public void recordEnd(ExecuteContext ctx) {
-        if (log.isEnabled(executeLoggingResult) && ctx.record() != null)
-            logMultiline("Record fetched", ctx.record().toString(), executeLoggingResult);
+        if (log.isTraceEnabled() && ctx.record() != null)
+            logMultiline("Record fetched", ctx.record().toString(), Level.FINER);
     }
 
     @Override
     public void resultEnd(ExecuteContext ctx) {
-        if (log.isEnabled(executeLoggingResult) && ctx.result() != null)
-            logMultiline("Fetched result", ctx.result().format(TXTFormat.DEFAULT.maxRows(executeLoggingResultNumberOfRows).maxColWidth(executeLoggingResultNumberOfColumns)), executeLoggingResult);
+        if (ctx.result() != null)
+            if (log.isTraceEnabled())
+                logMultiline("Fetched result", ctx.result().format(TXTFormat.DEFAULT.maxRows(500).maxColWidth(500)), Level.FINE);
+            else if (log.isDebugEnabled())
+                logMultiline("Fetched result", ctx.result().format(TXTFormat.DEFAULT.maxRows(5).maxColWidth(50)), Level.FINE);
     }
 
     @Override
     public void executeEnd(ExecuteContext ctx) {
-        if (log.isEnabled(executeLoggingResult) && ctx.rows() >= 0)
-            log.log("Affected row(s)", ctx.rows(), executeLoggingResult);
+        if (ctx.rows() >= 0)
+            if (log.isDebugEnabled())
+                log.debug("Affected row(s)", ctx.rows());
     }
 
     @Override
     public void outEnd(ExecuteContext ctx) {
-        if (log.isEnabled(executeLoggingRoutine) && ctx.routine() != null)
-            logMultiline("Fetched OUT parameters", "" + StringUtils.defaultIfNull(record(ctx.configuration(), ctx.routine()), "N/A"), executeLoggingRoutine);
+        if (ctx.routine() != null)
+            if (log.isDebugEnabled())
+                logMultiline("Fetched OUT parameters", "" + StringUtils.defaultIfNull(record(ctx.configuration(), ctx.routine()), "N/A"), Level.FINE);
     }
 
     @Override
     public void exception(ExecuteContext ctx) {
-        if (log.isEnabled(executeLoggingException))
-            log.log("Exception", ctx.exception(), executeLoggingException);
+        if (log.isDebugEnabled())
+            log.debug("Exception", ctx.exception());
     }
 
     @SuppressWarnings({ "rawtypes", "unchecked" })
@@ -229,9 +197,14 @@ public class LoggerListener extends DefaultExecuteListener {
         return result;
     }
 
-    private void logMultiline(String comment, String message, Log.Level level) {
+    private void logMultiline(String comment, String message, Level level) {
         for (String line : message.split("\n")) {
-            log.log(comment, line, level);
+            if (level == Level.FINE) {
+                log.debug(comment, line);
+            }
+            else {
+                log.trace(comment, line);
+            }
 
             comment = "";
         }
diff --git a/jOOQ/src/main/resources/META-INF/ABOUT.txt b/jOOQ/src/main/resources/META-INF/ABOUT.txt
index fd7a435d85..a65a2c4a4c 100644
--- a/jOOQ/src/main/resources/META-INF/ABOUT.txt
+++ b/jOOQ/src/main/resources/META-INF/ABOUT.txt
@@ -18,7 +18,6 @@ Authors and contributors of jOOQ or parts of jOOQ in alphabetical order:
 - Fabrice Le Roy
 - Gonzalo Ortiz Jaureguizar
 - Gregory Hlavac
-- Grenville Wilson
 - Henrik Sjöstrand
 - Ivan Dugic
 - Javier Durante