
<p class="has-drop-cap wp-block-paragraph">1 Idag på morgonen hade 28 hästar anmälts in till Prix d’Amérique (€1.000.000) på Vincennes på söndag. Det står klart att Jerry Riordans <strong>Aetos Kronos </strong>(e. Bold Eagle), Daniel Redéns <strong>Hail Mary</strong> (e. Googoo Gaagaa) och Sabine Kagebrants <strong>Joviality </strong>(e. Chapter Seven) ska försvara de blågula färgerna.</p>



<p class="wp-block-paragraph">Ytterligare en svensktränad travare har chansen att komma med och det är Robert Berghs <strong>Power </strong>(e. Googoo Gaagaa), vilken är förstareserv. Bakom Power står Björn Goop-tränade <strong>Moni Viking</strong> (e. Maharajah) och skulle han komma med får Sabine Kagebrant leta ny kusk till Joviality.</p>



<p class="wp-block-paragraph">Klockan 09.00 går anmälningstiden ut idag och efter det är det en strykningsomgång (onsdag) innan den definitiva startlistan spikas på torsdag klockan 12.00.</p>



<h2 class="wp-block-heading">Anmälda till Prix d’Amérique:</h2>



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



<ul class="wp-block-list">
<li><strong>Ampia Mede Sm</strong> (e. Ganymede) – Fabrice Souloy</li>



<li><strong>Emeraude de Bais</strong> (e. Repeat Love) – Benjamin Goetz</li>



<li><strong>Go On Boy </strong>(e. Password) – Romain Derieux</li>



<li><strong>Gu d’Heripre </strong>(e. Coktail Jet) – Fabrice Souloy</li>



<li><strong>Hokkaido Jiel</strong> (e. Brillantissime) – Jean-Luc Dersoir</li>



<li><strong>Hooker Berry</strong> (e. Booster Winner) – Jean-Michel Bazire</li>



<li><strong>Hussard du Landret </strong>(e. Bird Parker) – Benoït Robin</li>



<li><strong>Idao de Tillard</strong> (e. Severino) – Thierry Duvaldestin</li>



<li><strong>Inmarosa</strong> (e. Amiral Sacha) – Laurent-Claude Abrivard</li>



<li><strong>Izoard Vedaquais</strong> (e. Bird Parker) – Philippe Allaire</li>



<li><strong>Vivid Wise As</strong> (e. Yankee Glide) – Alessandro Gocciadoro</li>



<li><strong>Joviality</strong> (e. Chapter Seven) – Sabine Kagebrant</li>



<li><strong>Hohneck</strong> (e. Royal Dream) – Philippe Allaire</li>



<li><strong>Delia du Pommereux </strong>(e. Niky) – Sylvain Roger</li>



<li><strong>Flamme du Goutier</strong> (e. Ready Cash) – Thierry Duvaldestin</li>



<li><strong>Hail Mary </strong>(e. Googoo Gaagaa) – Daniel Redén</li>



<li><strong>Aetos Kronos </strong>(e. Bold Eagle) – Jerry Riordan</li>



<li><strong>Diable de Vauvert </strong>(e. Prince d’Espace) – Bertrand Le Beller</li>
</ul>



<p class="wp-block-paragraph"><strong>Reserver:</strong></p>



<ul class="wp-block-list">
<li><strong>Power</strong> (e. Googoo Gaagaa) – Robert Bergh</li>



<li><strong>Moni Viking </strong>(e. Maharajah) – Björn Goop</li>



<li><strong>Italiano Vero</strong> (e. Ready Cash) – Philippe Allaire</li>



<li><strong>Hanna des Molles</strong> (e. Village Mystic) – Laurent-Claude Abrivard</li>



<li><strong>Fakir du Lorault </strong>(e. Vaillant Cash) – Mickaël Charuel</li>



<li><strong>Eric the Eel </strong>(e. Muscle Hill) – Tomas Malmqvist</li>



<li><strong>Hip Hop Haufor</strong> (e. Up and Quick) – Christian Bigeon</li>



<li><strong>Sayonara</strong> (e. Donato Hanover) – Fredrik Wallin</li>



<li><strong>Galileo Bello</strong> (e. Aladin d’Ecajeul) – Anne Francoise Donati Marc</li>



<li><strong>Ibiki de Houelle</strong> (e. Love You) – Franck Leblanc</li>
</ul>



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



<p class="has-drop-cap wp-block-paragraph">2 Och i lördagens Prix du Luxembourg (€100.000) har det anmälts in 40 hästar och flera med svenskintressen är ”inne” i loppet. Det handlar om <strong>Dear Friend</strong>, <strong>Missle Hill</strong>, <strong>Eric the Eel</strong>, <strong>Jazzy Perrine</strong> och <strong>Great Skills</strong>.</p>



<p class="wp-block-paragraph">Första strykningen sker den 24 januari och dagen efter är det definitivanmälan i Grupp III-loppet över 2.100 meter autostart med 45.000 euro till vinnaren.</p>



<figure class="wp-block-image size-full"><img src="https://sulkysport.se/wp-content/uploads/2024/01/skarmavbild20240122kl.06.20.53.png" alt="" class="wp-image-544663"/></figure>



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



<p class="has-drop-cap wp-block-paragraph">3 Travveckan inleds med tävlingar på en svensk bana, i <strong>Halmstad</strong> (första start 18.20) ikväll med tio lopp på programmet.</p>



<p class="wp-block-paragraph">Hemmaamatören Hanna Lähdekorpi tillhör toppen bland landets B-tränare – trea i tränarligan 2023 – och 15 hästar finns på träningslistan. En som sticker ut är en toppstammad fyraåring och enda stoet i stallet där 14 hästar är valacker.</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2023/02/lahdekorpihannaadam2-617x333.jpg" alt="" class="wp-image-411204"/><figcaption class="wp-element-caption">Hanna Lähdekorpi. Foto Adam Ström/stalltz.se</figcaption></figure>



<p class="wp-block-paragraph">Det handlar om <strong>Muro Beach Pellini</strong> (e. Maharajah), som köptes av Lähdekorpi som ettåring, men hon har tagit tid på sig och det har dröjt innan segrarna börjat trilla in. Stoet debuterade först i oktober ifjol. Då slutade det med galopp, medan sedan har det lossnat och blivit tre vinster på fyra starter. Ikväll jagar hon en ny triumf med tränaren i vagnen.</p>



<p class="wp-block-paragraph">Muro Beach Pellini är lillasyster till avelshingsten och Kungapokalsvinnaren <strong>El Mago Pellini</strong> (e. Chocolatier), 1.10,6ak/6.541.901 kr.</p>



<p class="wp-block-paragraph"><a href="https://sulkysport.se/wp-content/uploads/2024/01/22v64.pdf" data-type="link" data-id="https://sulkysport.se/wp-content/uploads/2024/01/22v64.pdf" target="_blank" rel="noreferrer noopener">Här är startlistorna till måndagens tävlingar.</a></p>



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



<p class="has-drop-cap wp-block-paragraph">4 Idag inleds Prix d’Amérique-veckan på <strong>Vincennes</strong> utan svenska tränare. En blågul stämplad travare tävlar på den franska huvudstadsbanan. I Prix d’Orleans (€46.000) startar <strong>Lee Harvey Bros </strong>(e. Readly Express) i ett lopp med 20.700 euro till vinnaren för sexåriga hingstar/valacker över distansen 2.850 meter. Björn Goop finns med i samma lopp och han gästkuskar bakom Gennaro Casillos italienare <strong>Captor Delleselve</strong> (e. Nesta Effe), vilken debuterar på fransk mark.</p>



<p class="wp-block-paragraph">En svensk tränare har starthäst i Frankrike idag. I Agen-La Garenne ska Kristina Westerholms <strong>Kashmire Tonic </strong>(e. Ni Ho Ped d’Ombree) göra sin tredje start på fransk mark efter ha ”nollat” två gånger. I ett fyraåringslopp – Prix Gontaud de Nogaret (€18.000) – över distansen 2.575 meter sköter Pierrick Le Moel tömmarna.</p>



<p class="wp-block-paragraph"><a rel="noreferrer noopener" href="https://sulkysport.se/trav-och-galopp/paris-vincennes-2024-01-22/" data-type="link" data-id="https://sulkysport.se/trav-och-galopp/paris-vincennes-2024-01-22/" target="_blank">Startlistorna till Vincennes hittar ni här.</a></p>



<h2 class="wp-block-heading">Så gick det för svenskhoppen på Vincennes igår:</h2>



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



<ul class="wp-block-list">
<li><strong>Coquaholy</strong> (e. Orlando Vici) – Tomas Malmqvist – tvåa – 22.500 euro</li>



<li><strong>Isla Jet </strong>(e. Bold Eagle) – Tomas Malmqvist – trea – 12.600 euro</li>



<li><strong>Invictus Madiba</strong> (e. Booster Winner) – Tomas Malmqvist – fyra – 7.200 euro</li>



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



<li><strong>Zlatan Knick </strong>(e. Going Kronos) – David Cinier – opl. – 0 euro</li>
</ul>



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



<p class="has-drop-cap wp-block-paragraph">5 Andra raka Grupp III-vinsten tog <strong>Boccadamo</strong> (e. Ideale Luis-Marcena) för Roberto Vecchione igår i Florens. Efter ha inlett jumbo i fältet attackerade Roberto Vecchione i tredjespår 1.500 kvar och 200 meter senare placerades Boccadamo utvändigt om favoriten och ledande Akela Pal Ferm.</p>



<figure class="wp-block-image alignright size-sulky-liten2"><img src="https://sulkysport.se/wp-content/uploads/2024/01/skarmavbild20240121kl.19.46.22-350x151.jpg" alt="" class="wp-image-544634"/></figure>



<p class="wp-block-paragraph">Segergreppet kopplades kort före mål på 1.13,3a/2.020 meter och tvåa slutade Akela Pal Ferm (e. Maharajah) på 1.13,4. Tiondelen långsammare noterade Banderas Bi (e. Ganymede) som fastlåst trea.</p>



<p class="wp-block-paragraph">I starten innan vann Holger Ehlert-tränade Boccadamo Gran Premio Vittoria (€35.200) i Bologna. Boccadamo har tidigare vunnit Gran Premio Ettore E Mario Barbetta (f.d. Gran Premio Inverno). Modern <strong>Marcena</strong> (e. Lindy Lane), 1.15,5*/€21.684, är näst vinstrikast i en syskonskara på sju hästar och där <strong>Over Power</strong> (e. Malabar Circle Ås), 1.14,2/€25.008, lyckats bäst.</p>



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



<p class="has-drop-cap wp-block-paragraph">6 För sjunde året i rad satsar ATG på Spring Race på V75, där en multijackpot byggs upp till tävlingarna på Romme på påskdagen. I lördags lades de första pengarna in i potten, då ATG valt att från och med den 13 januari plocka undan 20 procent av jackpotpengarna och lägga dem i Rommepotten istället för att dela ut allt kommande lördag.</p>



<p class="wp-block-paragraph">I Bollnäs uteblev utdelningen på fem rätt och av pengarna i femrättspotten går 4,3 miljoner kronor in i multijackpotten. Resterande del – cirka 17,2 miljoner – delas ut i sjurättspotten på Axevalla på lördag.</p>



<p class="wp-block-paragraph"><strong>Tävlingsdagar Spring Race 2024:</strong></p>



<ul class="wp-block-list">
<li>Skärtorsdag 28 mars: <strong>Gävle</strong></li>



<li>Långfredag 29 mars: <strong>Färjestad</strong></li>



<li>Påskafton 30 mars: <strong>Klosterskogen</strong></li>



<li>Påskdagen 31 mars:<strong> Romme</strong></li>
</ul>



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



<p class="has-drop-cap wp-block-paragraph">7 Auktionsdatum för Danmark 2024 är satta. Två ettåringsauktioner kommer att arrangeras, enligt <a href="https://travservice.dk/danske-aaringsauktioner-holder-flyttedag/" data-type="link" data-id="https://travservice.dk/danske-aaringsauktioner-holder-flyttedag/" target="_blank" rel="noreferrer noopener">travservice.dk</a>. Derbyauktionen, som blir en hybridauktion‚ hålls lördagen den 24 augusti på Skovridergården och Restaurant Mash i nära anslutning till Charlottenlunds travbana.</p>



<p class="wp-block-paragraph">Ålborgauktionen hålls den 21 september i Vilhelmsborg.</p>
