
<p class="has-drop-cap wp-block-paragraph">1 Vintermeetinget är över för 2023-2024 och den mest spektakulära insatsen är förstås <strong>Jovialitys</strong> tredjeplats i Prix d’Amérique bakom Elitloppsinbjudne <strong>Idao de Tillard</strong> och Hokkaido Jiel, men också <strong>Global Agreements</strong> tre raka segrar i regi Alessandro Gocciadoro och där den senaste vinsten kom tidigare i veckan. </p>



<p class="wp-block-paragraph">Det hör inte till vanligheterna att en svenskfödd travare tar tre raka segrar på Vincennes. Tidigare har också<strong> Gigant Neo</strong>, <strong>Västerbo Daylight</strong> och <strong>Moving On</strong> klarat av den bedriften, men det finns två hästar som är ännu vassare.</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2021/10/021222gigantneomel-617x282.jpg" alt="" class="wp-image-226790"/><figcaption class="wp-element-caption">Stefan Melander vid en av sina tre segrar bakom Gigant Neo på Vincennes. Foto: stalltz.se</figcaption></figure>



<p class="wp-block-paragraph">Jörgen Westholms <strong>Super Light</strong> vann fyra raka under vintermeetinget 2003-2004 och innan dess – året var 1997 – hade Anders Lindqvists <strong>Rocky Kim</strong> tagit fem raka vinster på den franska huvudstadsovalen. Samtliga vinster togs i monté och med Jean-Michel Bazire i sadeln.</p>



<h2 class="wp-block-heading">Här är Rocky Kims segersvit:</h2>



<p class="wp-block-paragraph"><strong>Datum – Lopp (€) – Ryttare</strong></p>



<ul class="wp-block-list">
<li>16/2 1997 – Prix Djerid (€60.000) – Jean-Michel Bazire</li>



<li>1/3 1997 – Prix Henri Desmontils (€68.000) – Jean-Michel Bazire</li>



<li>29/3 1997 – Prix d’Istres (€32.000) – Jean-Michel Bazire</li>



<li>15/4 1997 – Prix Cornelia (€46.000) – Jean-Michel Bazire</li>



<li>25/4 1997 – Prix Antigone (€46.000) – Jean-Michel Bazire</li>
</ul>



<h2 class="wp-block-heading">Super Light:</h2>



<p class="wp-block-paragraph"><strong>Datum – Lopp (€) – Körsven</strong></p>



<ul class="wp-block-list">
<li>11/12 2003 – Prix de Belfort (€55.000) – Jörgen Westholm</li>



<li>1/1 2004 – Prix du Croise-Laroche (€55.000) – Nicolas Roussel</li>



<li>11/1 2004 – Prix de Rouen (€100.000) – Jörgen Westholm</li>



<li>1/2 2004 – Prix de Champtoce (€60.000) – Jörgen Westholm</li>
</ul>



<h2 class="wp-block-heading">Gigant Neo:</h2>



<p class="wp-block-paragraph"><strong>Datum – Lopp (€) – Körsven</strong></p>



<ul class="wp-block-list">
<li>23/11 2002 – Prix Marcel Laurent (€95.000) – Stefan Melander</li>



<li>22/12 2002 – Prix Ariste Hemard (€95.000) – Stefan Melander</li>



<li>18/1 2003 – Prix Roederer (€95.000) – Stefan Melander</li>
</ul>



<h2 class="wp-block-heading">Västerbo Daylight:</h2>



<p class="wp-block-paragraph"><strong>Datum – Lopp (€) – Ryttare</strong></p>



<ul class="wp-block-list">
<li>9/1 2005  – Prix de l&#8217;ile-de-France (€150.000) – Nathalie Henry</li>



<li>6/2 2005 – Prix du Calvados (€140.000) – Louis Baudron</li>



<li>20/2 2005 – Prix Djerid (€100.000) – Nathalie Henry</li>
</ul>



<h2 class="wp-block-heading">Moving On</h2>



<p class="wp-block-paragraph"><strong>Datum – Lopp (€) – Körsven</strong></p>



<ul class="wp-block-list">
<li>13/12 2014 – Prix de Laval (€68.000) – David Thomain</li>



<li>4/1 2015 – Prix Hersilie (€95.000) – Franck Nivard</li>



<li>25/1 2015 – Prix Helen A Johansson (€105.000 – Franck Nivard</li>
</ul>



<h2 class="wp-block-heading">Global Agreement:</h2>



<p class="wp-block-paragraph"><strong>Datum – Lopp (€) – Körsven</strong></p>



<ul class="wp-block-list">
<li>29/12 2023 – Prix de Montauban (€56.000) – Gabriele Gelormini</li>



<li>4/2 2024 – Prix de la Creuse (€56.000) – Alessandro Gocciadoro</li>



<li>28/2 2024 – Prix de Sedan (€59.000) – Alessandro Gocciadoro</li>
</ul>



<p class="has-text-align-center wp-block-paragraph">***</p>



<p class="has-drop-cap wp-block-paragraph">2 Femton svenskfödda vinnare blev det under vintermeetinget 2023-2024 och det är sex fler än ifjol. Så här har det sett ut de senaste fem åren: <strong>2019-2020 </strong>(12), <strong>2020-2021</strong> (11), <strong>2021-2022</strong> (17), <strong>2022-2023</strong> (9) och <strong>2023-2024</strong> (15).</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2023/12/00243165012scoopdyga-617x411.jpg" alt="" class="wp-image-538605"/><figcaption class="wp-element-caption">Global Agreement är bäst av de svenskfödda hästarna med tre vinster i Paris under vintermeetinget. Foto: Scoopdyga</figcaption></figure>



<h2 class="wp-block-heading">Alla svenskfödda vinnarna under vintermeetinget: </h2>



<p class="wp-block-paragraph"><strong>Namn (far) – Lopp (€) – Tränare</strong></p>



<ul class="wp-block-list">
<li><strong>Unico Broline</strong> (e. Cantab Hall) – Prix de Cosse le Vivien (€68.000) – Sofia Aronsson</li>



<li><strong>Junkie</strong> (e. Varenne) – Prix de Chinon (€40.000) – Pierre Levesque</li>



<li><strong>Glamorous Rain</strong> (e. Muscle Hill) – Prix de Blois (€90.000) – Daniel Redén</li>



<li><strong>San Moteur </strong>(e. Panne de Moteur) – Prix du Bourbonnais (€120.000) – Björn Goop</li>



<li><strong>Karat River</strong> (e. Muscle Hill) – Prix de Reims (€80.000) – Johan Untersteiner</li>



<li><strong>Oscar L.A. </strong>(e. Ready Cash) – Prix de Saint-James (€75.000) – Fabrice Souloy</li>



<li><strong>Huis Clos </strong>(e. Bird Parker) – Prix d’Ispagnac (€52.000) – Pierre Levesque</li>



<li><strong>Global Agreement</strong> (e. Love You) – Prix de Montauban (€56.000) – Alessandro Gocciadoro</li>



<li><strong>Marion Fouty Bon</strong> (e. Mister J.P.) – Prix de Ranes (€52.000) – Laurent-Claude Abrivard</li>



<li><strong>G.K. Justus</strong> (e. Brad de Veluwe) – Prix de Chateauroux (€46.000) – Stefan Arvidsson</li>



<li><strong>Global Agreement</strong> (e. Love You) – Prix de la Creuse (€56.000) – Alessandro Gocciadoro</li>



<li><strong>Beat Generation</strong> (e. Bird Parker) – Prix Indienne (€71.000) – Jörgen Westholm</li>



<li><strong>Spartakus </strong>(e. Father Patrick) – Prix de Lambale (€35.000) – David Cinier</li>



<li><strong>Global Agreement</strong> (e. Love You) – Prix de Lure (€52.000) – Alessandro Gocciadoro</li>



<li><strong>Killiam Fromentro</strong> (e. Villiam) – Alessandro Gocciadoro – etta – 20.700 euro</li>
</ul>



<p class="has-text-align-center wp-block-paragraph">***</p>



<p class="has-drop-cap wp-block-paragraph">3Han har tre kuskchampionat från 1987, 1988 och 1991 på Mantorptravet på meritlistan, men för drygt tio år sedan lämnade profilen Göran B Andersson in proffslicensen och blev amatörtränare. I sommar fyller Göran 70 år och han håller igång som amatörtränare med fem hästar på träningslistan och en framgångsrik dotter i duktiga montéryttarinnan Julia Andersson.</p>



<p class="wp-block-paragraph">Valacken <strong>Estrella Diamante</strong> (e. Charly du Noyer) anslöt till stallet förra våren från Björn Goop och hade då fem segrar och ytterligare fyra pallplatser på 16 starter bakom sig. Hos Göran B tävlingsdebuterade hästen i höstas och fem starter i nya regin slutade med två nya segrar.</p>



<p class="wp-block-paragraph">Idag i <strong>Eskilstuna</strong> (första start 13.45) väntar årsdebut för sexåringen, som från tillägg tillsammans med Kim Eriksson jagar livets åttonde seger.</p>



<p class="wp-block-paragraph">Annars drar dagens tävlingsutbud på svensk mark igång redan vid lunchtid, lagom till eliten på både herr- och damsidan passerat mållinjen för Vasaloppet i Mora, med tävlingar i <strong>Östersund</strong> (första start 12.20). </p>



<p class="wp-block-paragraph"><a href="https://sulkysport.se/wp-content/uploads/2024/02/240303.pdf" target="_blank" rel="noreferrer noopener">Här är startlistorna till söndagens tävlingar.</a></p>



<p class="has-text-align-center wp-block-paragraph">***</p>



<p class="has-drop-cap wp-block-paragraph">4 Jorma Kontio gjorde en lyckad resa till sitt hemland igår och vann en dubbel i Tammerfors. <strong>Hierro Boko</strong> (e. From Above-Staro Almighty) tog sin tredje raka seger och travade 1.13,6a/2.100 meter när han hämtade hem 10.000 euro.</p>



<figure class="wp-block-image size-full"><img src="https://sulkysport.se/wp-content/uploads/2020/12/kontiojormafemling.jpg" alt="" class="wp-image-123947"/><figcaption class="wp-element-caption">Jorma Kontio. Foto Adam Ström/Stalltz.se</figcaption></figure>



<p class="wp-block-paragraph">Lika mycket tjänade <strong>Show Must Go On</strong> (e. Ready Cash-Poppy Lavec) när han räknade in sin andra triumf på två dagar. Igår vann han på 1.15,3a/2.100 meter och i fredags i Seinäjoki noterade valacken 1.15,9a/1.600 meter för Niko Jokela och då var förstapriset 1.300 euro. Tränar gör Reima Kuisla.</p>



<p class="has-text-align-center wp-block-paragraph">***</p>



<p class="has-drop-cap wp-block-paragraph">5 Vintermeetinget må vara över på Vincennes, men på de franska landsortsbanorna växlar man nu istället upp allt mer. Idag är det åtta banor som arrangerar travlopp på fransk mark, men svenskintresse går blott skönja på en av banorna. I <strong>Hyeres</strong> (första start kl. 14.30) körs EU-loppet Grand Prix du Journal Var Matin (€28.000) och där gör svenskfödde <strong>Digital Indy</strong> (e. Super Photo Kosmos) sin andra start i David Ciniers regi.</p>



<p class="wp-block-paragraph">Sjuåringen blev diskvalificerad i Agen för två veckor sedan, men laddar nu om i ett lopp där även David Cinier plockar ut sin svenskbekanta nyförvärv <strong>Marrakesh</strong> (e. Ready Cash) som i Timo Nurmos regi slutade fyra i Finskt Travkriterium 2018.</p>



<h2 class="wp-block-heading">Så gick det för de blågula hoppen på Vincennes igår.</h2>



<p class="wp-block-paragraph"><strong>Namn (far) – Tränare – Placering – Euro</strong></p>



<ul class="wp-block-list">
<li><strong>Killiam Fromentro </strong>(e. Villiam) – Alessandro Gocciadoro – etta – 20.700 euro</li>



<li><strong>Keynote (</strong>e. Face Time Bourbon) – Tomas Malmqvist – trea – 12.600 euro</li>



<li><strong>Usain Töll </strong>(e. Googoo Gaagaa) – Genaro Casillo – fyra – 7.200 euro</li>



<li><strong>Gardner Shaw </strong>(e. Ready Cash) – Yannick Henry – femma – 3.400 euro</li>



<li><strong>Dear Friend </strong>(e. Orlando Vici) – Daniel Wäjersten – sexa – 1.800 euro</li>



<li><strong>Kitty Call</strong> (e. Ready Cash) – Tomas Malmqvist – sjua – 520 euro</li>



<li><strong>Kobayashi</strong> (e. Face Time Bourbon) – Tomas Malmqvist – diskad</li>



<li><strong>Koelho de Nappes</strong> (e. Charly du Noyer) – Tomas Malmqvist – diskad – 0 euro</li>



<li><strong>Jazzy Perrine </strong>(e. Django Riff) – Tomas Malmqvist – struken</li>
</ul>



<p class="has-text-align-center wp-block-paragraph">***</p>



<p class="has-drop-cap wp-block-paragraph">6 Gävleproffset Oskar Kylin Blom har inlett året urstarkt med 14 tränarsegrar på 56 starter och fler kan mycket väl hans nyförvärv <strong>Lill Hans</strong> (e. Bork Odin), 1.25,0am/528.700 kr, bidra med vad det lider.</p>



<p class="wp-block-paragraph">Sjuåringen har gjort 51 starter i Jörgen Westholms regi varav sju slutat med seger och bland dem har triumfen i Zorn-loppet för fyraåringar värd 60.000 kronor varit den mest penningstinna.</p>



<p class="wp-block-paragraph">Efter en stark start på fjolåret har hästen gått segerlös sedan april och nu blir det Gävletränaren Kylin Bloms uppgift att försöka få hästen på rätt köl.</p>



<p class="has-text-align-center wp-block-paragraph">***</p>



<p class="has-drop-cap wp-block-paragraph">7 På Hyllstofta Stuteri i Klippan har norskan <strong>Catherine’s Chic </strong>(e. Love You-Cassiopeia Dream), 1.12,4ak/716.065 kr, fått en hingst efter danske storstjärnan <strong>Ecurie D.</strong> och han blir också stoets nästa partner i aveln.</p>



<figure class="wp-block-image size-full"><img src="https://sulkysport.se/wp-content/uploads/2024/03/catherineschicsfolefterecuried.jpg" alt="" class="wp-image-556633"/><figcaption class="wp-element-caption">Catherine&#8217;s Chics föl efter Ecurie D. Foto: privat</figcaption></figure>



<p class="wp-block-paragraph">Sedan tidigare har Catherine’s Chic två avkommor, varav <strong>Custom Chrono </strong>(e. Bird Parker), 1.15,5ak/53.800 kr, startade fem gånger (0-0-1) och var finalist i Svensk Uppfödningslöpning.</p>



<p class="wp-block-paragraph">Mormor <strong>Cassiopeia Dream </strong>(e. Andover Hall), 1.14,7/$4.117, är halvsyster till tidigare Stefan Melander-tränade <strong>Nato Dream </strong>(e. Donato Hanover), 1.10,6ak*/1.968.923 kr, <strong>Appalach Dream</strong> ($88.260), <strong>Altlantic Dream Ad</strong> ($58.835) och <strong>Nuriev Dream </strong>($57.209).</p>



<p class="wp-block-paragraph">Ni vet väl att ni kan maila in fölrapporter för fri publicering? Uppge mor, far och kön på fölet. Skriv också om ni bestämt vilken hingst stoet ska gå till i år och skicka gärna med en bild tagen på bredden.<br><a href="mailto:claes@sulkysport.se">Maila till Sulkysport</a></p>
