diff --git a/src/http/input/body/SparqlUpdateBodyParser.ts b/src/http/input/body/SparqlUpdateBodyParser.ts
index 8b0d871e8..83bed8ab4 100644
--- a/src/http/input/body/SparqlUpdateBodyParser.ts
+++ b/src/http/input/body/SparqlUpdateBodyParser.ts
@@ -28,8 +28,9 @@ export class SparqlUpdateBodyParser extends BodyParser {
     try {
       algebra = translate(sparql, { quads: true, baseIRI: metadata.identifier.value }) as Algebra.Update;
     } catch (error: unknown) {
-      this.logger.warn('Could not translate SPARQL query to SPARQL algebra', { error });
-      throw new BadRequestHttpError(createErrorMessage(error), { cause: error });
+      const message = createErrorMessage(error);
+      this.logger.warn(`Could not translate SPARQL query to SPARQL algebra: ${message}`);
+      throw new BadRequestHttpError(message, { cause: error });
     }
 
     // Prevent body from being requested again
diff --git a/src/logging/LazyLogger.ts b/src/logging/LazyLogger.ts
index f16f799f4..3299c3535 100644
--- a/src/logging/LazyLogger.ts
+++ b/src/logging/LazyLogger.ts
@@ -20,10 +20,10 @@ export class LazyLogger extends Logger {
     this.label = label;
   }
 
-  public log(level: LogLevel, message: string, meta: any): Logger {
+  public log(level: LogLevel, message: string): Logger {
     if (!this.logger) {
       this.logger = this.lazyLoggerFactory.loggerFactory.createLogger(this.label);
     }
-    return this.logger.log(level, message, meta);
+    return this.logger.log(level, message);
   }
 }
diff --git a/src/logging/Logger.ts b/src/logging/Logger.ts
index 01b0c90d3..b2f727c80 100644
--- a/src/logging/Logger.ts
+++ b/src/logging/Logger.ts
@@ -13,15 +13,15 @@ export abstract class Logger {
    * @param message - The message to log.
    * @param meta - Optional metadata to include in the log message.
    */
-  public abstract log(level: LogLevel, message: string, meta?: any): Logger;
+  public abstract log(level: LogLevel, message: string): Logger;
 
   /**
    * Log a message at the 'error' level.
    * @param message - The message to log.
    * @param meta - Optional metadata to include in the log message.
    */
-  public error(message: string, meta?: any): Logger {
-    return this.log('error', message, meta);
+  public error(message: string): Logger {
+    return this.log('error', message);
   }
 
   /**
@@ -29,8 +29,8 @@ export abstract class Logger {
    * @param message - The message to log.
    * @param meta - Optional metadata to include in the log message.
    */
-  public warn(message: string, meta?: any): Logger {
-    return this.log('warn', message, meta);
+  public warn(message: string): Logger {
+    return this.log('warn', message);
   }
 
   /**
@@ -38,8 +38,8 @@ export abstract class Logger {
    * @param message - The message to log.
    * @param meta - Optional metadata to include in the log message.
    */
-  public info(message: string, meta?: any): Logger {
-    return this.log('info', message, meta);
+  public info(message: string): Logger {
+    return this.log('info', message);
   }
 
   /**
@@ -47,8 +47,8 @@ export abstract class Logger {
    * @param message - The message to log.
    * @param meta - Optional metadata to include in the log message.
    */
-  public verbose(message: string, meta?: any): Logger {
-    return this.log('verbose', message, meta);
+  public verbose(message: string): Logger {
+    return this.log('verbose', message);
   }
 
   /**
@@ -56,8 +56,8 @@ export abstract class Logger {
    * @param message - The message to log.
    * @param meta - Optional metadata to include in the log message.
    */
-  public debug(message: string, meta?: any): Logger {
-    return this.log('debug', message, meta);
+  public debug(message: string): Logger {
+    return this.log('debug', message);
   }
 
   /**
@@ -65,7 +65,7 @@ export abstract class Logger {
    * @param message - The message to log.
    * @param meta - Optional metadata to include in the log message.
    */
-  public silly(message: string, meta?: any): Logger {
-    return this.log('silly', message, meta);
+  public silly(message: string): Logger {
+    return this.log('silly', message);
   }
 }
diff --git a/src/server/middleware/StaticAssetHandler.ts b/src/server/middleware/StaticAssetHandler.ts
index 369f33ff7..10aff7312 100644
--- a/src/server/middleware/StaticAssetHandler.ts
+++ b/src/server/middleware/StaticAssetHandler.ts
@@ -118,7 +118,7 @@ export class StaticAssetHandler extends HttpHandler {
           reject(new NotFoundHttpError(`Cannot find ${request.url}`));
         // In other cases, we might already have started writing, so just hang up
         } else {
-          this.logger.warn(`Error reading asset ${filePath}: ${error.message}`, { error });
+          this.logger.warn(`Error reading asset ${filePath}: ${error.message}`);
           response.end();
           asset.destroy();
           resolve();
diff --git a/src/util/GuardedStream.ts b/src/util/GuardedStream.ts
index b124008e7..2ed923cff 100644
--- a/src/util/GuardedStream.ts
+++ b/src/util/GuardedStream.ts
@@ -41,8 +41,7 @@ function guardingErrorListener(this: Guarded, error: Error): void {
     this[guardedErrors].push(error);
     if (!this[guardedTimeout]) {
       this[guardedTimeout] = setTimeout((): void => {
-        const message = `No error listener was attached but error was thrown: ${error.message}`;
-        logger.error(message, { error });
+        logger.error(`No error listener was attached but error was thrown: ${error.message}`);
       }, 1000);
     }
   }
diff --git a/test/unit/logging/LazyLogger.test.ts b/test/unit/logging/LazyLogger.test.ts
index 19bb8fb96..a077275fc 100644
--- a/test/unit/logging/LazyLogger.test.ts
+++ b/test/unit/logging/LazyLogger.test.ts
@@ -24,11 +24,11 @@ describe('LazyLogger', (): void => {
     };
     lazyLoggerFactory.loggerFactory = dummyLoggerFactory;
 
-    expect(logger.log('debug', 'my message', { abc: true })).toBe(dummyLogger);
+    expect(logger.log('debug', 'my message')).toBe(dummyLogger);
     expect(dummyLoggerFactory.createLogger).toHaveBeenCalledTimes(1);
     expect(dummyLoggerFactory.createLogger).toHaveBeenCalledWith('MyLabel');
     expect(dummyLogger.log).toHaveBeenCalledTimes(1);
-    expect(dummyLogger.log).toHaveBeenCalledWith('debug', 'my message', { abc: true });
+    expect(dummyLogger.log).toHaveBeenCalledWith('debug', 'my message');
   });
 
   it('reuses the logger for repeated calls.', async(): Promise<void> => {
@@ -40,14 +40,14 @@ describe('LazyLogger', (): void => {
     };
     lazyLoggerFactory.loggerFactory = dummyLoggerFactory;
 
-    expect(logger.log('debug', 'my message 1', { abc: true })).toBe(dummyLogger);
-    expect(logger.log('debug', 'my message 2', { abc: true })).toBe(dummyLogger);
-    expect(logger.log('debug', 'my message 3', { abc: true })).toBe(dummyLogger);
+    expect(logger.log('debug', 'my message 1')).toBe(dummyLogger);
+    expect(logger.log('debug', 'my message 2')).toBe(dummyLogger);
+    expect(logger.log('debug', 'my message 3')).toBe(dummyLogger);
     expect(dummyLoggerFactory.createLogger).toHaveBeenCalledTimes(1);
     expect(dummyLoggerFactory.createLogger).toHaveBeenCalledWith('MyLabel');
     expect(dummyLogger.log).toHaveBeenCalledTimes(3);
-    expect(dummyLogger.log).toHaveBeenNthCalledWith(1, 'debug', 'my message 1', { abc: true });
-    expect(dummyLogger.log).toHaveBeenNthCalledWith(2, 'debug', 'my message 2', { abc: true });
-    expect(dummyLogger.log).toHaveBeenNthCalledWith(3, 'debug', 'my message 3', { abc: true });
+    expect(dummyLogger.log).toHaveBeenNthCalledWith(1, 'debug', 'my message 1');
+    expect(dummyLogger.log).toHaveBeenNthCalledWith(2, 'debug', 'my message 2');
+    expect(dummyLogger.log).toHaveBeenNthCalledWith(3, 'debug', 'my message 3');
   });
 });
diff --git a/test/unit/logging/Logger.test.ts b/test/unit/logging/Logger.test.ts
index 39f18dc54..36ba27616 100644
--- a/test/unit/logging/Logger.test.ts
+++ b/test/unit/logging/Logger.test.ts
@@ -2,45 +2,43 @@ import { Logger } from '../../../src/logging/Logger';
 
 describe('Logger', (): void => {
   let logger: Logger;
-  let meta: any;
   beforeEach(async(): Promise<void> => {
     logger = new (Logger as any)();
     logger.log = jest.fn();
-    meta = { abc: 123 };
   });
 
   it('Error delegates to log.', async(): Promise<void> => {
-    logger.error('my message', meta);
+    logger.error('my message');
     expect(logger.log).toHaveBeenCalledTimes(1);
-    expect(logger.log).toHaveBeenCalledWith('error', 'my message', meta);
+    expect(logger.log).toHaveBeenCalledWith('error', 'my message');
   });
 
   it('Warn delegates to log.', async(): Promise<void> => {
-    logger.warn('my message', meta);
+    logger.warn('my message');
     expect(logger.log).toHaveBeenCalledTimes(1);
-    expect(logger.log).toHaveBeenCalledWith('warn', 'my message', meta);
+    expect(logger.log).toHaveBeenCalledWith('warn', 'my message');
   });
 
   it('Info delegates to log.', async(): Promise<void> => {
-    logger.info('my message', meta);
+    logger.info('my message');
     expect(logger.log).toHaveBeenCalledTimes(1);
-    expect(logger.log).toHaveBeenCalledWith('info', 'my message', meta);
+    expect(logger.log).toHaveBeenCalledWith('info', 'my message');
   });
   it('Verbose delegates to log.', async(): Promise<void> => {
-    logger.verbose('my message', meta);
+    logger.verbose('my message');
     expect(logger.log).toHaveBeenCalledTimes(1);
-    expect(logger.log).toHaveBeenCalledWith('verbose', 'my message', meta);
+    expect(logger.log).toHaveBeenCalledWith('verbose', 'my message');
   });
 
   it('Debug delegates to log.', async(): Promise<void> => {
-    logger.debug('my message', meta);
+    logger.debug('my message');
     expect(logger.log).toHaveBeenCalledTimes(1);
-    expect(logger.log).toHaveBeenCalledWith('debug', 'my message', meta);
+    expect(logger.log).toHaveBeenCalledWith('debug', 'my message');
   });
 
   it('Silly delegates to log.', async(): Promise<void> => {
-    logger.silly('my message', meta);
+    logger.silly('my message');
     expect(logger.log).toHaveBeenCalledTimes(1);
-    expect(logger.log).toHaveBeenCalledWith('silly', 'my message', meta);
+    expect(logger.log).toHaveBeenCalledWith('silly', 'my message');
   });
 });
diff --git a/test/unit/util/GuardedStream.test.ts b/test/unit/util/GuardedStream.test.ts
index 38bdd5985..6b4c556e8 100644
--- a/test/unit/util/GuardedStream.test.ts
+++ b/test/unit/util/GuardedStream.test.ts
@@ -157,9 +157,7 @@ describe('GuardedStream', (): void => {
       // Only the first error gets logged
       jest.advanceTimersByTime(900);
       expect(logger.error).toHaveBeenCalledTimes(1);
-      expect(logger.error).toHaveBeenCalledWith(
-        'No error listener was attached but error was thrown: 0', { error: errors[0] },
-      );
+      expect(logger.error).toHaveBeenCalledWith('No error listener was attached but error was thrown: 0');
 
       jest.advanceTimersByTime(1000);
       expect(logger.error).toHaveBeenCalledTimes(1);