Nothing marks the end of summer like the school’s re-opening and the start of the annual September releases campaign.
This is the second tranche of international releases, or ‘Hors Bordeaux’, following the 50+ wines launched by négociants in March.
{"content":"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"}