diff --git a/docs/sections/release_notes/release-notes.rst b/docs/sections/release_notes/release-notes.rst
index 501a37f..ed8957b 100644
--- a/docs/sections/release_notes/release-notes.rst
+++ b/docs/sections/release_notes/release-notes.rst
@@ -11,6 +11,7 @@
 Previous Release Notes
 ======================
 
+- :ref:`Kohn <release_notes_kohn>`
 - :ref:`Jakarta <release_notes_jakarta>`
 - :ref:`Istanbul <release_notes_istanbul>`
 - :ref:`Honolulu <release_notes_honolulu>`
@@ -25,7 +26,7 @@
 Abstract
 ========
 
-This document provides the release notes for the Kohn release.
+This document provides the release notes for the London release.
 
 Summary
 =======
@@ -42,33 +43,51 @@
 | **Docker images**                    | N/A                                  |
 |                                      |                                      |
 +--------------------------------------+--------------------------------------+
-| **Release designation**              | Kohn                                 |
+| **Release designation**              | London                               |
 |                                      |                                      |
 +--------------------------------------+--------------------------------------+
-| **Release date**                     | 2022/12/05                           |
+| **Release date**                     | 2023/06/xx                           |
 |                                      |                                      |
 +--------------------------------------+--------------------------------------+
 
 New features
 ------------
 
-* Kubernetes support for version up to 1.23.8
-* Helm support for version up to Helm: 3.8.2
-* Kubespray version used for automated deployment 2.19 (used for automated deployment)
-* Initial Setup for "ONAP on ServiceMesh" deployment
+* Introduction of "Production" ONAP setup, including:
 
-  * using Istio 1.14.1 as SM platform
-  * including Istio Ingress Gateway for external access
-  * modify 90% of ONAP component charts to support SeviceMesh
+  * Istio Service Mesh based deployment
+  * Ingress (Istio-Gateway) deployment and usage as standard external access method
+  * Internal Security provided by ServiceMesh and Component2Component AuthorizationPolicies
+  * External Security by introducing AuthN/Z using Keycloak and OAuth2Proxy for Ingress Access
+
+* Removal of unsupported components (AAF, Portal, Contrib,...)
+* Update of Helmcharts to use common templates and practices
+* Optional support for Cassandra 4.x using k8ssandra-operator
+
+* `REQ-1349 <https://jira.onap.org/browse/REQ-1349>`_ Removal of AAF.
+  Internal communication encryption and authorization is offered by ServiceMesh
+
+* `REQ-1350 <https://jira.onap.org/browse/REQ-1350>`_ All component must be
+  able to run without MSB. Component helm charts modified to use MSB optionally
+  and test the components during Daily and Gating with and without MSB
+
+* `REQ-1351 <https://jira.onap.org/browse/REQ-1351>`_ External secure
+  communication only via Ingress.
+  Ingress resources created by templates and Ingress installation is described
+  in the OOM documents
 
 **Bug fixes**
 
 A list of issues resolved in this release can be found here:
-https://jira.onap.org/projects/OOM/versions/11499
-
+https://jira.onap.org/projects/OOM/versions/11500
 
 **Known Issues**
 
+* Components not working under ServiceMesh
+
+  * CDS UI
+  * SO Monitor UI
+  * CLI
 
 Deliverables
 ------------
@@ -83,7 +102,7 @@
 
 - :ref:`Project Description <oom_project_description>` - a guide for developers of OOM
 - :ref:`oom_dev_guide` - a guide for developers of OOM
-- :ref:`oom_infra_setup_guide` - a guide for those setting up the environments that OOM will use
+- :ref:`oom_infra_guide` - a guide for those setting up the environments that OOM will use
 - :ref:`oom_deploy_guide` - a guide for those deploying OOM on an existing cloud
 - :ref:`oom_user_guide` - a guide for operators of an OOM instance
 - :ref:`oom_access_info_guide` - a guide for operators who require access to OOM applications
@@ -96,19 +115,16 @@
 
 * Cassandra version needs to be updated to support new Python version
   see `OOM-2900 <https://jira.onap.org/browse/OOM-2900>`_
+  In London supported as option (using k8ssandra-operator), see :ref:`oom_base_optional_addons`
 
 Workarounds
 -----------
 
-
 Security Notes
 --------------
 
 **Fixed Security Issues**
 
-* Fixed vulnerabilities for oom-platform-cert-service
-  see `Fixes <https://wiki.onap.org/pages/viewpage.action?spaceKey=SV&title=Kohn+OOM>`_
-
 References
 ==========
 
