<!-- vinabox-journaliste — 03/08/2026 — Castel acte III -->
[vinabox_en_bref titre="Crise Castel en bref"]
<ul>
<li><strong>3ème révocation</strong> de Gregory Clerc par les actionnaires familiaux en 6 mois (2 février, puis une 2ème fois, puis 3 août 2026)</li>
<li>Clerc <strong>refuse de partir</strong> : son mandat de PDG opérationnel n'est pas lié, selon lui, à celui d'administrateur d'IBBM</li>
<li>IBBM, la <strong>société de tête</strong> du groupe : celui qui la contrôle contrôle 2,7 millions d'hectolitres de vin et 1,1 milliard d'euros de CA</li>
<li>La <strong>décision finale</strong> est attendue à la Haute Cour de Singapour à l'automne 2026</li>
<li>En attendant, le groupe continue de <strong>fonctionner normalement</strong> selon les deux camps</li>
</ul>
[/vinabox_en_bref]

<p>Six mois. Trois votes de révocation. Et toujours le même homme à la tête du premier groupe vin français. La saga Castel Vins entre dans un nouvel épisode ce lundi 3 août 2026, avec une troisième assemblée générale de la société IBBM qui confirme l'éviction de son PDG Gregory Clerc — lequel, de son côté, indique qu'il reste <em>« totalement mobilisé »</em> et n'a pas l'intention de lâcher les rênes.</p>

<p>Pour comprendre ce feuilleton estival qui agite toute la filière vitivinicole française, il faut d'abord saisir ce qu'est le groupe Castel, et pourquoi ce conflit de gouvernance dépasse largement la querelle familiale qu'il semble être en surface.</p>

<!-- STAT TILES -->
<div style="display:flex;flex-wrap:wrap;gap:12px;margin:24px 0;">
  <div style="flex:1;min-width:160px;background:#f9f4ef;border-left:4px solid #61262A;padding:16px;border-radius:4px;">
    <div style="font-size:2em;font-weight:bold;color:#61262A;">1,1 Md€</div>
    <div style="font-size:0.9em;color:#555;">Chiffre d'affaires 2025</div>
  </div>
  <div style="flex:1;min-width:160px;background:#f9f4ef;border-left:4px solid #61262A;padding:16px;border-radius:4px;">
    <div style="font-size:2em;font-weight:bold;color:#61262A;">2,7 M hl</div>
    <div style="font-size:0.9em;color:#555;">Premier opérateur de vins français</div>
  </div>
  <div style="flex:1;min-width:160px;background:#f9f4ef;border-left:4px solid #61262A;padding:16px;border-radius:4px;">
    <div style="font-size:2em;font-weight:bold;color:#61262A;">40 000</div>
    <div style="font-size:0.9em;color:#555;">Collaborateurs dans le monde</div>
  </div>
</div>

<h2>Castel Vins : le géant discret du vin de tous les jours</h2>

<p>Fondé par Pierre Castel (1926–2022), le groupe éponyme est omniprésent dans les rayons des supermarchés, même si vous n'avez peut-être jamais eu conscience de le voir. Derrière des marques de vins de pays à prix accessibles, des vins en Bag-in-Box et des références bordelaises entrée de gamme, Castel représente <strong>2,7 millions d'hectolitres de vin</strong> écoulés chaque année — soit environ un verre de vin sur dix bu en France.</p>

<p>Le groupe est aussi un acteur majeur en Afrique (boissons gazeuses, bières, distribution alimentaire) avec ses filiales <strong>Castel Afrique</strong> et <strong>Somdia</strong>. C'est cette double dimension — vin français + empire africain — qui fait de la société de tête IBBM (Investment Beverage Business Management), domiciliée à Singapour, le nœud stratégique du conflit actuel.</p>

<p>À la mort de Pierre Castel en 2022, l'empire a été transmis à ses héritiers, dont sa fille unique <strong>Romy Castel</strong> et son neveu <strong>Alain Castel</strong>. Depuis, la question de qui dirige réellement ce groupe s'est transformée en bataille juridique à plusieurs fronts, entre <a href="https://www.vinabox.fr/actu/filiere-business/castel-vins-crise-gouvernance-romy-alain-castel-evoques-2026/">Singapour</a> et Genève.</p>

<h2>Ce qui s'est passé le 3 août 2026</h2>

<p>Trois fois en six mois, les actionnaires familiaux ont convoqué une assemblée générale d'IBBM pour <strong>révoquer les mandats d'administrateur</strong> de Gregory Clerc et de Pierre Baer. Et trois fois, Gregory Clerc a contesté la portée juridique de cette décision.</p>

<p>La difficulté tient à la structure même du groupe. IBBM est la <em>société de tête</em> : celui qui la contrôle contrôle en cascade Castel Vins, Castel Afrique et Somdia. Mais Clerc et ses partisans (via les holdings <strong>DF Holding</strong> et <strong>Cassiopée</strong>) soutiennent qu'un mandat d'administrateur révoqué à IBBM n'affecte pas les fonctions de PDG opérationnel du groupe.</p>

<p><em>« Mon énergie est entièrement consacrée à la poursuite du développement du groupe Castel »</em>, a déclaré Gregory Clerc via un communiqué commun de DF Holding et Cassiopée, publié ce 3 août. <em>« Les succès présents et à venir sont la meilleure des réponses aux vaines agitations de certains. »</em></p>

<p>En face, Romy Castel a réaffirmé que <em>« la volonté des actionnaires est constante, majoritaire, et confirmée assemblée après assemblée »</em>, et que <em>« l'ensemble des résolutions a été adopté »</em>. La famille maintient que contrôler IBBM, c'est contrôler le groupe — et elle est juridiquement majoritaire à chaque vote.</p>

<h2>Pourquoi Gregory Clerc peut-il rester malgré trois votes contre lui ?</h2>

<p>La réponse est dans la structure même du litige. Depuis février 2026, la <a href="https://www.vinabox.fr/actu/filiere-business/castel-vins-vote-eviction-vente-decoupe-singapour-2026/">Haute Cour de Singapour</a> a été saisie du conflit. Et les actionnaires familiaux eux-mêmes ont décidé de <strong>suspendre les effets des résolutions de révocation</strong> dans l'attente du jugement au fond — prévu à l'automne 2026.</p>

<p>Autrement dit : les votes existent, ils sont comptabilisés, mais leur application est gelée par la procédure judiciaire en cours. C'est précisément ce gel qui permet à Clerc de rester en poste tout en ayant été formellement révoqué trois fois.</p>

<p>Pour le camp familial, il s'agit de <em>« respecter les procédures judiciaires »</em>. Pour le camp Clerc, ces assemblées répétées constituent une <em>« stratégie d'agitation médiatique permanente »</em> qui ne touche pas au fonctionnement opérationnel du groupe.</p>

<h2>Et le vin dans tout ça ? Ce qui change (ou pas) pour les amateurs</h2>

<p>Sur le terrain, les deux camps s'accordent sur un point : le groupe continue de fonctionner normalement. Les vignobles tournent, les bouteilles sont embouteillées, la distribution suit son cours. Si vous avez l'habitude de saisir un vin de pays à moins de 5 euros dans votre supermarché habituel, il y a de bonnes chances que Castel Vins soit quelque part dans la chaîne.</p>

<p>À plus long terme, c'est la question de la stratégie du groupe qui dépendra de l'issue du bras de fer. Une direction familiale plaide souvent pour une gestion patrimoniale, un PDG externe pour une vision de développement et d'acquisition. Dans un secteur vitivinicole mondial en crise structurelle — comme l'illustrent les <a href="https://www.vinabox.fr/actu/filiere-business/surplus-vin-mondial-2026-vrac-californie-bordeaux-amateurs/">surplus records de 2026</a> — la gouvernance du plus grand opérateur français de vin de pays n'est pas anodine.</p>

<p>La décision de la Haute Cour de Singapour, attendue à l'automne 2026, tranchera probablement la question de fond : qui, de la structure IBBM ou du mandat opérationnel, détient réellement le pouvoir de nommer ou révoquer le PDG d'un groupe de cette taille.</p>

<p><em>Source : Vitisphere, Alexandre Abellan, 3 août 2026 — communiqués officiels DF Holding/Cassiopée et déclarations Romy Castel.</em></p>

<h2>Vos questions sur la crise Castel Vins</h2>

<details style="margin-bottom: 10px; border: 1px solid #d39c44; padding: 10px; border-radius: 5px;">
    <summary style="font-weight: bold; color: #61262A; cursor: pointer;">Qu'est-ce que IBBM et pourquoi est-ce central dans le conflit ?</summary>
    <p style="margin-top: 5px;">IBBM (Investment Beverage Business Management) est la société holding de tête du groupe Castel, domiciliée à Singapour. Elle contrôle en cascade Castel Vins (vin français), Castel Afrique (boissons, bières) et Somdia (agroalimentaire Afrique). Qui contrôle IBBM contrôle l'ensemble du groupe — c'est pourquoi les deux camps se battent pour sa gouvernance plutôt que pour les filiales opérationnelles.</p>
</details>

<details style="margin-bottom: 10px; border: 1px solid #d39c44; padding: 10px; border-radius: 5px;">
    <summary style="font-weight: bold; color: #61262A; cursor: pointer;">Qui est Gregory Clerc, le PDG qui résiste aux révocations ?</summary>
    <p style="margin-top: 5px;">Gregory Clerc est un avocat fiscaliste suisse nommé PDG du groupe Castel en 2023, après la mort de Pierre Castel (fondateur, 1926–2022). Il s'appuie sur les holdings DF Holding et Cassiopée pour contester la portée des révocations de son mandat d'administrateur à IBBM, en soutenant que ce mandat est distinct de ses fonctions de PDG opérationnel du groupe.</p>
</details>

<details style="margin-bottom: 10px; border: 1px solid #d39c44; padding: 10px; border-radius: 5px;">
    <summary style="font-weight: bold; color: #61262A; cursor: pointer;">Quand saura-t-on qui dirige vraiment Castel Vins ?</summary>
    <p style="margin-top: 5px;">La Haute Cour de Singapour doit rendre sa décision au fond à l'automne 2026. C'est elle qui tranchera la question juridique centrale : est-ce que révoquer les mandats d'administrateur à IBBM suffit à mettre fin aux fonctions de PDG opérationnel ? En attendant, les effets des résolutions de révocation restent suspendus à la demande des actionnaires eux-mêmes.</p>
</details>

<div style="background:#f9f4ef;border-left:4px solid #61262A;padding:16px;margin:24px 0;border-radius:4px;">
<strong>Vous suivez l'actu du secteur vin ?</strong> Retrouvez chaque semaine nos analyses sur la filière vitivinicole dans notre sélection <a href="https://www.vinabox.fr/box-vin/">box vin</a> et nos guides experts.
</div>








Connexion rapide pour commenter :