
<p class="has-drop-cap">1 Ingen amerikansk travare har vunnit Prix d’Amérique sedan Jimmy Takters <strong>Moni Maker</strong> 1999 och senast en USA-född hingst toppade i Frankrikes största lopp var Berndt Lindstedt och <strong>Dart Hanover</strong> 1973.</p>



<p>Nu gör USA-födde <strong>Beads</strong> ett försök, men Archangel-sonen gjorde ingen lycklig i våras när han kom från USA till Norge och Frode Hamre. Fyra starter och lika många galopper, varav Erik Adielsson körde de tre första gångerna och Vidar Hop vid det fjärde tillfället.</p>



<p>Sedan en tid tillbaka finns 1.08-travaren i Jean-Michel Bazires regi och till 24 au Trot säger han<em>:</em></p>



<p><em>– Beads har jobbat hårt i en månad, men fortfarande är det lite eftersläpning i hans gångart, men motorn är bra. En del bra saker har Beads gjort i träningen den senaste tiden. Viktigt är att hans kusk (Alexandre Abrivard) är vaksam. Däremot är jag inte orolig över hästens förmåga att klara av Vincennes bana.</em></p>



<p>Nu är det upp till Alexandre Abrivard att få honom på rätt köl och dessutom i fransk voltstart. Idag ska Beads ut i Prix du Bourbonnais (€120.000) och det gäller att vara bland de tre främsta för att kvala in till Prix d’Amérique. Loppet innehåller flera stortravare och däribland Elitloppsvinnaren <strong>Etonnant</strong>.</p>



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



<p><strong>Prix du Bourbonnais</strong> (€120.000)<br>4-10 år.<br><strong>Priser:</strong> 54.000-30.000-16.800-9.600-6.000-2.400-1.200 euro<br><em>2.850 meter.</em></p>



<ol class="wp-block-list">
<li><strong>Oracle Tile</strong> – Clément Duvaldestin</li>



<li><strong>Hip Hop Haufor</strong> – Christian Bigeon</li>



<li><strong>Gala Tejy</strong> – Thomas Chalon</li>



<li><strong>Beads</strong> – Alexandre Abrivard</li>



<li><strong>Hussard du Landret</strong> – Benoit Robin</li>



<li><strong>Hirondelle Sibey</strong> – Louis Baudouin</li>



<li><strong>Decoloration </strong>– Gabriele Gelormini</li>



<li><strong>Violetto Jet</strong> – Benjamin Rochard</li>



<li><strong>Callmethebreeze</strong> – David Thomain</li>



<li><strong>Zarenne Fas</strong> – Jean-Michel Bazire</li>



<li><em><strong>Gu d’Heripre</strong> – Franck Nivard – struken</em></li>



<li><strong>Hooker Berry</strong> – Nicolas Bazire</li>



<li><strong>Flamme du Goutier</strong> – Théo Duvaldestin</li>



<li><strong>Delia du Pommereux</strong> – Sylvain Roger</li>



<li><strong>Etonnant </strong>– Anthony Barrier</li>



<li><strong>Vivid Wise As</strong> – Matthieu Abrivard</li>
</ol>



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



<p class="has-drop-cap">2 Faktum är att det avgörs ett än mer penningstint lopp på <strong>Vincennes</strong> (13.23) än Prix du Bourbonnais under söndagseftermiddagen. Prix Ready Cash (€200.000) – tidigare namngivet Prix de l’Etoile – är ett Grupp I-klassat treåringslopp med 90.000 euro till vinnaren, men det har inte lockat särskilt stort intresse.</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2021/10/prixlouiscauchois3-617x536.jpg" alt="" class="wp-image-233745"/><figcaption class="wp-element-caption">Just A Gigolo och Franck Nivard. Foto: Gerard Forni</figcaption></figure>



<p>Blott tio hästar drabbar samman bland vilka kullettan <strong>Just A Gigolo</strong> (e. Boccador du Simm) utmärker sig ihop med Orsi Mangelli-segraren <strong>Diamond Francis </strong>(e. Exploit Caf). Jarmo Niskanen bidrar i sin tur med <strong>Joyful Diva</strong> (e. Sam Bourbon) som körs av Benjamin Rochard.</p>



<p>Tomas Malmqvist startar därtill två hästar på Vincennes. <strong>Iron Jet </strong>(e. Charly du Noyer) prövar lyckan i Prix Wow Hipcover Assurances Hippiques (€44.000) och <strong>Exauido Vic</strong>i (e. Quatre Juillet) dyker upp i Prix de Crecy La Chapelle (€70.000).</p>



<p><a href="https://sulkysport.se/trav-och-galopp/paris-vincennes-2022-12-11/" target="_blank" rel="noreferrer noopener">Startlistorna till Vincennes tävlingar hittar ni här.</a></p>



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



<p><strong>Hästnamn (far) – tränare – placering – intjänade prispengar</strong></p>



<ul class="wp-block-list">
<li><strong>Isla Jet</strong> (e. Bold Eagle) – Tomas Malmqvist – sexa – 2.400 euro</li>



<li><strong>Imhatra Am</strong> (e. Muscle Hill) – Jörgen Westholm – oplacerad</li>



<li><strong>Mr Perfection</strong> (e. Andover Andover) – Jim Oscarsson – oplacerad</li>



<li><strong>Short In Cash</strong> (e. Ready Cash) – Tomas Malmqvist – oplacerad</li>
</ul>



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



<p class="has-drop-cap">3 Att travare från Norden numera tycks ha klippkort till andra sidan Atlanten är ingen nyhet, men nu åker en irländsk segermaskin över till USA för att söka lyckan. <strong>Harry Knows </strong>(e. Armstrong Jet-Aurora) har vunnit 23 av 33 starter, sprungit in 34.180 euro och har utsetts till årets travare av Irish Harness Racing Association två år i rad. Femåringen går i träning till Shane Tritton i staten New York och meningen är att han ska tävla på Yonkers Raceway och Meadowlands.</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2022/12/harryknows12032022ironiaart1024-617x348.jpg" alt="" class="wp-image-390168"/><figcaption class="wp-element-caption">Harry Knows och Patrick Kane Jr.</figcaption></figure>



<p>– Vi tror att det amerikanska systemet passar honom bättre med bilstart än det franska voltstartsystemet, säger hästens körsven Patrick Kane Jr. till The Irish Field.</p>



<p>Harry Knows gjorde sin sista start på irländsk mark den 20 november på Portmarnock Raceway och där vann han finalen i Red Mills All-Ireland Series Trot med 13 längder.</p>



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



<p class="has-drop-cap">4 Arqana Trot har gjort klart med datum för auktionerna i Frankrike nästa år. Den franska auktionsfirman rivstartar året med Ventes du Prix d’Amérique (25-27 januari) i Paris, medan ettåringsauktionen Ventes de Yearlings Sélectionnés hålls 6-8 september i Deauville. Så här ser auktionsåret ut för dela 2023:</p>



<h2 class="wp-block-heading">Datum – Auktion – Plats</h2>



<ul class="wp-block-list">
<li>25-27 januari – Ventes du Prix d’Amérique – Vincennes/Paris</li>



<li>30 mars – Vente de Printemps – Deauville</li>



<li>27 juni – Vente d’Eté – Cabourg</li>



<li>6-8 september – Ventes de Yearlings Sélectionnés – Deauville</li>



<li>19 september – Vente Mixte de Septembre – Deauville</li>



<li>7-8 november – Vente d’Automne – Cabourg</li>
</ul>



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



<p class="has-drop-cap">5 Under massor av år har italienskfödda hästar tävlat med felaktiga och för låga prissummor på svensk mark. Påstötningar har inte saknats, men nu har Svensk Travsport vaknat till liv. <br>Från och med 1 januari 2023 kommer även kusk- och tränarprovisionen inräknas i startprissumman, precis som det görs i Sverige.</p>



<p><a href="https://www.travsport.se/arkiv/nyheter/20222/december/justerad-berakning-av-italienska-prissummor/" target="_blank" rel="noreferrer noopener">Läs mer här.</a></p>



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



<p class="has-drop-cap">6 Årets 28:e och sista tävlingsdag väntar på <strong>Kalmartravet</strong> (första start 13.45), som är enda svenska bana som tävlar idag. Halmstadkusken Stefan Persson har plockat hem kuskchampionatet två år i rad och finns på plats i eftermiddag för att hämta sin tredje raka titel. Stefan har vunnit 26 lopp på Smålandsbanan i år, nio fler än tvåan Kevin Oscarsson, och kan putsa siffrorna ytterligare med åtta uppsittningar i eftermiddag.</p>



<p>Desto mer spännande är det på tränarsidan, där Fredrik Persson och Johan Untersteiner båda står på 21 tränarsegrar vardera inför avslutningen. Persson tar ut sex hästar vid årsfinalen på hemmaplan, medan Untersteiner har en kvintett till start.</p>



<p>På söndagsspelet Grand Slam 75 är det dessutom jackpot med totalt 5,4 miljoner kronor extra i sju-, sex- och femrättspotterna. </p>



<p><a href="https://sulkysport.se/wp-content/uploads/2022/12/11gs75.pdf" target="_blank" rel="noreferrer noopener">Här är startlistorna till Kalmars tävlingar.</a></p>



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



<p class="has-drop-cap">7 Det är inte bara på fransk mark – läs Vincennes – som det tävlas idag om större prispengar. På Ippodromo Castelluccio dei Sauri i Foggia bjuds det på Grupp III-loppet Gran Premio Capitanata Memorial Luigi Maglione (€40.040) för fyraåringar. Distansen är 2.060 meter och loppet startas med bil.</p>



<p><strong>Gran Premio Capitanata Memorial L. Maglione</strong> (€40.040)<br>Fyraåringar.<br><em>2.060 meter, autostart.</em></p>



<ol class="wp-block-list">
<li><strong>Corsaronero Font</strong> (e. Oropuro Bar) – Antonio di Nardo</li>



<li><strong>Cointreau</strong> (e. Nad al Sheba) – Manuel Pistone</li>



<li><strong>Corazon Bar</strong> (e. Oropuro Bar) – Cosimo Cangelosi</li>



<li><strong>Conan Op</strong> (e. Mago d’Amore) – Italo Tamborrino</li>



<li><strong>Chiara Degliulivi</strong> (e. Napoleon) – Umberto di Vincenzo</li>



<li><strong>Cervantonpridegar</strong> (e. Varenne) – Vincenzo Gallo</li>



<li><strong>Cocis Mp</strong> (e. Manofmanymissions) – Andrea Farolfi</li>



<li><strong>Caronte Trebi</strong> (e. Nad al Sheba) – Vincenzo Luongo</li>



<li><strong>Catullo Jet </strong>(e. Maharajah) – Antonio Simioli</li>



<li><strong>Canarino Jet</strong> (e. Naglo) – Filippo Gallo</li>



<li><strong>Corallo Pisano</strong> (e. Louvre) – Marco Volpato</li>



<li><strong>Colosseuss</strong> (e. Raja Mirchi) – Sabato di Vincenzo</li>



<li><strong>Cherie Vit</strong> (e. Crazed) – Crescenzo Maione</li>



<li><strong>Crystal Pan</strong> (e. Ideale Luis) – Enrico Bellei</li>
</ol>
