
<p class="has-drop-cap wp-block-paragraph">1Idag avgörs det första B-loppet inför Prix d’Amerique då den 57:e upplagan av av Prix de Bretagne (€120.000) ska köras på Vincennes. Svenskhoppen är två till antalet då Björn Goops <strong>San Moteur</strong> (e. Janne de Moteur) och Thierry Duvaldestins norskägde <strong>Oracle Tile</strong> (e. Ready Cash) finns med i startfältet och lyckas någon av dem vinna blir de historiska.</p>



<p class="wp-block-paragraph">Under årens lopp har nämligen aldrig någon svenskfödd häst vunnit Prix de Bretagne och som bäst har ”de blågula” tre andraplatser. Såväl år 2004 och 2005 var <strong>Super Light</strong> (e. Super Arnie) tvåa och samma placering nådde <strong>Hot Tub</strong> (e. Sugarcane Hanover) två år senare.<br>Kan San Moteur blir den första vinnaren när han gör sin första start på fransk mark? Lång distans har inte San Moteur tävlat på sedan han vann Lyon Grand Prix den 7 maj ifjol på Åby på 1.11,9a/2.640 meter, men att han trivs över lång distans råder inga tvivel om. Totalt har det blivit fem starter (3-1-1) på 2.640 meter och andraplatsen togs i Svenskt Travkriterium medan tredjeplatsen kom i Svenskt Travderby.</p>



<p class="wp-block-paragraph">Motståndet är stentufft. Prix d’Amérique-vinnaren <strong>Hooker Berry</strong> (e. Booster Winner) och tvåan i samma löpning, <strong>Ampia Mede Sm</strong> (e. Ganymede) , finns med liksom Harper Hanovers-vinnaren <strong>Diable de Vauvert</strong> (e. Prince d’Espace) och <strong>Horsy Dream</strong> (e. Scipion du Goutier), som var favorit i vinterns Prix d’Amérique.</p>



<h2 class="wp-block-heading">Startlista Prix de Bretagne (€120.000), 2.700 meter</h2>



<p class="wp-block-paragraph"><strong>Priser: </strong>54.000-30.000-16.800-9.600-6.000-2.400-1.200 euro.<br><em>Namn – Körsven (tränare)</em></p>



<ol class="wp-block-list">
<li>Hip Hop Haufor – Christian Bigeon</li>



<li>Farah des Caux – Alexis Garandeau</li>



<li>Just Love You – Alexandre Abrivard (Laurent-Claude Abrivard</li>



<li>Ideal du Pommeau – Matthieu Abrivard (Sébastien Guarato)</li>



<li>Oracle Tile – Théo Duvaldestin (Thierry Duvaldestin)</li>



<li>Ganay de Banville – Jean-Michel Bazire</li>



<li>Hokkaido Jiel – David Thomain (Jean-Luc Dersoir)</li>



<li>Horsy Dream – Eric Raffin (Pierre Belloche)</li>



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



<li>Izoard Vedaquais – Benjamin Rochard (Philippe Allaire)</li>



<li>Elvis du Vallion – Yoann Lebourgeois (Charles Cuiller)</li>



<li>Hanna des Molles – Laurent-Claude Abrivard</li>



<li>Gu d’Heripre – Francois Lagadeuc (Fabrice Souloy)</li>



<li>Bleff Dipa – Roberto Vecchione (Holger Ehlert)</li>



<li>San Moteur – Björn Goop</li>



<li>Diable de Vauvert – Tony Le Beller (Bertrand Le Beller)</li>



<li>Ampia Mede Sm – Franck Nivard (Fabrice Souloy)</li>



<li>Hooker Berry – Nicolas Bazire (Jean-Michel Bazire)</li>
</ol>



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



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2023/07/yuvaraj-617x333.jpg" alt="" class="wp-image-476223"/><figcaption class="wp-element-caption">Yuvaraj och Gustav Johansson. Foto Mathias Hedlund/Sulkysport.</figcaption></figure>



<p class="has-drop-cap wp-block-paragraph">2Det kryllar av svenskintressen på Vincennes (första start kl. 13.23) denna söndag! Utöver den svenskfödda duon i Prix de Bretagne så tävlar 15 hästar med blågul koppling i de övriga åtta ramloppen.</p>



<p class="wp-block-paragraph">Flest syns i inledningsloppet Prix de Mandelieu (€46.000) för sex- och sjuåriga hästar som högst tjänat 150.000 euro. Montéuppgörelsen har samlat Håkan B Johanssons <strong>Yuvaraj</strong> (e. Maharajah), Björn Goops <strong>Twigs Honor</strong> (e. Voltigeur de Hyrt), som rids av Jonathan Carre, samt den fransktränade, men svenskfödda trion <strong>Happy Fem</strong> (e. Ready Cash), <strong>Dante Godiva</strong> (e. Up And Quick) och <strong>Beethoven</strong> (e. From Above).</p>



<p class="wp-block-paragraph">I Prix De Cosse Le Vivien (€68.000) för sex- till tioåriga hästar som högst tjänat 315.000 euro kryllar det av bekanta namn. <strong>Oscar L.A.</strong> (e. Ready Cash) gör debut för Fabrice Souloy, Björn Goop får chansen bakom Sofia Aronssons <strong>Unico Broline</strong> (e. Cantab Hall), Johan Svensson prövar lyckan med <strong>Kuyt F.Boko</strong> (e. Conway Hall) och <strong>Toto Barosso</strong> (e. Ready Cash) körs av sin tränare Johan Untersteiner.</p>



<p class="wp-block-paragraph">I evakueringsloppet Prix d’Aigues Mortes (€56.000) för sju- och åttaåringar möts Christoffer Erikssons <strong>Hurricane River</strong> (e. Up and Quick) och Björn Goops <strong>Geoffrey d’Am</strong> (e. Timoko).</p>



<p class="wp-block-paragraph">Tomas Malmqvist prövar med en duo i semi classique-klassade Prix Pierre Plazen (€120.000) i form av <strong>Kobayashi</strong> (e. Face Time Bourbon) och <strong>Kapitano de Source</strong> (e. Ready Cash) och i de treåriga stonas motsvarighet Prix Guy Deloison (€120.000) finns Stall Courant-ägda <strong>Kalmia Perrine</strong> (e. Django Riff) med bland deltgarna.</p>



<p class="wp-block-paragraph">Sist, men inte minst ska Björn Goops <strong>Jamaica Island</strong> (e. Bold Eagle) nämnas. Hon kommer bli hårt betrodd i fyraåringsloppet Prix Jean Maurice Beteau (€35.000).</p>



<p class="wp-block-paragraph"><a href="https://sulkysport.se/trav-och-galopp/paris-vincennes-2023-11-19/" target="_blank" rel="noreferrer noopener">Här är startlistorna till Vincennes topptävlingar idag.</a></p>



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



<p class="has-drop-cap wp-block-paragraph">3Färjestad (start 13.45) är ensam på plan på svensk mark idag. En som har en spännande eftermiddag framför sig är Mantorptränaren Kim Eriksson, som kör två hästar – och båda har segermöjligheter. </p>



<p class="wp-block-paragraph">Kim vann 114 lopp och körde in över tio miljoner kronor som kusk 2019, men har kört färre lopp i år än de senaste åren. Nu sitter han upp bakom hästen som han körde i Svenskt Travderby 2018, nämligen <strong>Bo C. </strong>(e. Maharajah).<br>Hästen tränades då av sin ägare och uppfödare Bo E Nilsson, men numera är det Natacha Hammer – amatör på Axevalla – som sköter träningen. Dit kom Bo C. i maj och i tredje starten i nya regin kom första segern. Kusk? Kim Eriksson som körde Bo C.för första gången på nästan två år.</p>



<p class="wp-block-paragraph">Den andra uppsittningen har Kim också bra koll på. Han talar väl om David Persson-tränade <strong>Smajlis</strong> (e. Classic Photo). Valacken ståtar med fyra raka segrar och vid de tre senaste har Kim suttit i sulkyn!</p>



<p class="wp-block-paragraph"><a href="https://sulkysport.se/wp-content/uploads/2023/11/19gs75.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">4Storhästägaren Lennart Ågren – Srf Stable – bjuder in till auktion hos Travera ikväll och 15 starthästar bjuds ut till försäljning. Bland dessa finns ett par hästar som köptes för riktigt stora pengar.</p>



<p class="wp-block-paragraph"><strong>Bordeaux Face</strong> (e. Propulsion) kostade tre miljoner kronor när Lennart Ågren ropade in hästen på Kolgjini Yearling Sale för tre år sedan. På tävlingsbanan har det inte blivit någon succé så här långt för fyraåringen som väntar på första segern.<br>Danskfödde <strong>Godfather</strong> (e. Bold Eagle) är med 1,1 miljoner danska kronor 2019 den dyraste ettåringen genom tiderna på dansk auktion. Godfather var tvåa i danska Kriteriet för två år sedan.</p>



<p class="wp-block-paragraph">De främsta meriterna har jänkaren <strong>Arnold N.Dicky</strong> (e. Bar Hopping), 1.10,0ak*/1.785.686 kr, som satte världsrekord som tvååring i USA, och <strong>Sidney Celeber</strong> (e. Readly Express), 1.11,5ak/1.007.195 kr.</p>



<p class="wp-block-paragraph"><a rel="noreferrer noopener" href="https://www.travera.nu/partnerauktion/srf-19-november-2023/" target="_blank">Här går det att se alla hästar som säljs och följa budgivningen under kvällen.</a></p>



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



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2021/06/mrlavec-617x333.jpg" alt="" class="wp-image-175545"/><figcaption class="wp-element-caption">Mr Lavec med Jimmy Takter vann även Kriteriet 1994. Foto Stefan Melander/Stalltz.se</figcaption></figure>



<p class="has-drop-cap wp-block-paragraph">5Italienska Grupp I-loppet för fyraåringar, Gran Premio Unione Europea (€209.000), har nästan 100-åriga anor och är mer känt under sitt tidigare namn Gran Premio d’Europa.<br>Det har blivit en hel del svenska framgångar genom åren. <strong>Mustard</strong> (Sören Nordin), <strong>Evita Broline</strong> (Håkan Wallner), <strong>Lass Quick</strong> (Olle Goop), <strong>Indus</strong> (Lars Lindberg), <strong>Mr Lavec</strong> (Jimmy Takter), <strong>Snappy Trio</strong> (Roger Grundin), <strong>Kramer Boy</strong> (Johnny Takter) och <strong>Uronometro</strong> (Leif Berggren) finns bland vinnarna och på senare år har både Björn Goop och Örjan Kihlström gästspelat med seger som resultat.</p>



<p class="wp-block-paragraph">Idag i Modena är det dags för årets upplaga, men det saknas svenska travare i startlistan. Däremot startar tre hästar som vunnit lopp på svensk mark i år.<br>Det handlar om Alessandro Gocciadoros duo <strong>Danger Bi</strong> (e. Bird Parker) samt <strong>Denver</strong> <strong>Gio</strong> (e. Southwind Frank) och därtill bidrar Gennaro Casillo med den färske Axel Jensens-vinnaren <strong>Demon</strong> (e. Royal Blessed).</p>



<h2 class="wp-block-heading">Startlista Gran Premio Unione Europea</h2>



<p class="wp-block-paragraph"><em>2.060 meter autostart</em></p>



<ol class="wp-block-list">
<li><strong>Dimitri Ferm</strong> – Andrea Farolfi (Mauro Baroncini)</li>



<li><strong>Desiderio d&#8217;Esi</strong> – Santo Mollo (Mauro Baroncini)</li>



<li><strong>Daniele Jet</strong> – Gaetano di Nardo (Sabato Bevilacqua)</li>



<li><strong>Diamond Truppo</strong> – Antonio Simioli (Alessandro Gocciadoro)</li>



<li><strong>Denver Gio</strong> – Giampaolo Minnucci (Alessandro Gocciadoro)</li>



<li><strong>Danger Bi</strong> – Alessandro Gocciadoro</li>



<li><strong>Denzel Treb</strong> – Cesare Ferranti (Manuele Matteini)</li>



<li><strong>Dolce Viky</strong> – Federico Esposito (Alessandro Gocciadoro)</li>



<li><strong>Diamond Francis</strong> – Vincenzo P.Dell&#8217;Annunziata (Walter Zanetti)</li>



<li><strong>Yahoo Diamant</strong> – Michael Nimczyk (Wolfgang Nimczyk)</li>



<li><strong>Demon</strong> – Antonio di Nardo (Gennaro Casillo)</li>
</ol>



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



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2023/08/boremikkel3-617x333.jpg" alt="" class="wp-image-479355"/><figcaption class="wp-element-caption">Bore Mikkel vann direkt i debuten för nye tränaren Thor Borg. Foto Mathias Hedlund/Sulkysport</figcaption></figure>



<p class="has-drop-cap wp-block-paragraph">6Hos Öystein Tjomsland var han kullens vinstrikaste treåring och har i år vunnit Svenskt Travderby. Igår debuterade fyraårige <strong>Bore Mikkel</strong> (e. Moe Odin) för sin nye tränare Thor Borg och tillsammans med Eirik Höitomt blev det enkel seger på Jarlsberg.<br>Höitomt provade en bit för ledning efter 600 meter, men fick svar. Istället kopplade Bore Mikkel greppet ut ur slutsvängen och gled undan till karriärens 16:e seger (på 21 starter!) på 1.25,6/2.140 meter.</p>



<p class="wp-block-paragraph">Fyra norska höstfinaler för unghästar, två vardera för varm- och kallblod, kördes på Jarlsberg och ende svensktränade hästen var Kristian Lindbergs <strong>M.P.Atle</strong> (e. Tekno Odin). Denne plockade hem tredjepriset från ledningen bland de treåriga kallbloden, där <strong>Mjölner Borken</strong> (e. Tangen Trygg) och Jan Roar Mjölneröd segrade på 1.27,9/2.120 meter trots galopp.<br>Varmblodsfinalerna vann av Geir Vegard Gundersens treåring <strong>Charron</strong> (e. Code Bon) och Magnus Teien Gundersen på vassa 1.13,2a/2.100 meter, respektive fyraårige <strong>Striking Eagle</strong> (e. Bold Eagle), tränad av Bo Westergård, på 1.14,2a/2.100 meter.</p>



<p class="wp-block-paragraph">Frode Hamres storloppsess <strong>Stoletheshow</strong> (e. Dream Vacation) lekte hem högsta klassen för varmblod från ledningen med tränaren i vagnen, medan Tjomslands topphäst <strong>Grislefaksen G.L.</strong> (e. Järvsöfaks) tog sjätte raka i snabbloppet för kallblod.</p>



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



<p class="has-drop-cap wp-block-paragraph">7Den danske Kriterievinnaren <strong>Just Hans</strong> (e. Maharajah) är profilen när Dansk Avelslopp för treåriga hingstar och valacker avgörs i Ålborg under eftermiddagen.<br>Bent Svendsens segerstaplare har ett ”staket” i resultatraden och ser ut att ha en mycket god chans att bärga karriärens elfte seger i den 14:e starten då Kriteriefyran <strong>Joy Me</strong> (e. Luckycharm Hanover) framstår som värsta utmanare.<br>Jägersrotränaren Jörgen Lorentzen finns representerad i loppet genom <strong>I Can Win Gardenia</strong> (e. Ens Snapshot) som slutade trea i sitt uttagningslopp.</p>



<p class="wp-block-paragraph"><strong>Startlista Dansk Avelslopp för treåriga hingstar och valacker</strong><br><em>2.140 meter autostart, förstapris: 75.000 danska kronor</em></p>



<ol class="wp-block-list">
<li><strong>Just Hans</strong> (e. Maharajah) – Bent Svendsen</li>



<li><strong>Joy Me</strong> (e. Luckycharm Hanover) – Nicklas Korfitsen (Mariann T Nielsen)</li>



<li><strong>Jack Wee</strong> (e. Zola Boko) – Knud Mönster (Jörn Nörlem)</li>



<li><strong>Ice Cool Surprise</strong> (e. Ens Snapshot) – Kasper Foget (Anders Peter Braüner)</li>



<li><strong>Infinitve</strong> (e. Michael’s Turn) – Jeppe Juel</li>



<li><strong>Isak Smed</strong> (e. From Above U.S.) – Birger Jörgensen (Elund Christensen)</li>



<li><strong>Jeff</strong> (e. Wishing Stone) – Michael Lönborg (Jan Friis)</li>



<li><strong>Jolly Lifetime</strong> (e. Luckycharm Hanover) – Kenneth Andersen (Pauli Andersen)</li>



<li><strong>Iceman</strong> (e. Wishing Stone) – Dennis Kristiansen</li>



<li><strong>I Can Win Gardenia</strong> (e. Ens Snapshot) – Flemming Jensen (Jörgen Lorentzen)</li>



<li><strong>Jaguar</strong> (e. Ens Snapshot) – Morten Friis (Jan Friis)</li>



<li><strong>Julius Östervang</strong> (e. Wishing Stone) – Pauli Andersen</li>
</ol>



<p class="wp-block-paragraph"><strong>Startlista Dansk Avelslopp för treåriga ston</strong><br><em>2.140 meter autostart, förstapris: 75.000 danska kronor</em></p>



<ol class="wp-block-list">
<li><strong>Indiana Stone</strong> (e. Wishing Stone) – Nicklas Korfitsen (Bo Westergård)</li>



<li><strong>Juno</strong> (e. Great Challenger) – Michael Lönborg (Christina Beck)</li>



<li><strong>Joyforrun</strong> (e. Maharajah) – Anders F Jensen</li>



<li><strong>Ice Cool Money</strong> (e. Maharajah) – Steen Juul</li>



<li><strong>Jackie Wee</strong> (e. Maharajah) – Bent Svendsen</li>



<li><strong>Ironheart</strong> (e. Maharajah) – Henrik Lönborg (Anders Jensen)</li>



<li><strong>Jacqueline Mosebo</strong> (e. Great Challenger) – Knud Mönster (Katrine Mikkelsen)</li>



<li><strong>Jumpin Charles</strong> (e. Ens Snapshot) – Kasper Foget (Charlotte Lohmann)</li>



<li><strong>Isolde</strong> (e. Broad Bahn) – Jeppe Juel</li>



<li><strong>Jamaica Gardenia</strong> (e. Ens Snapshot) – Jeppe Rask (Torben Hovgaard)</li>



<li><strong>Jacana</strong> (e. Wishing Stone) – Anders Pedersen</li>
</ol>

Fokustema
Morgonsvepet
Läs senare
San Moteur redo för äventyret
San Moteur och 16 andra hästar med svensk anknytning på Vincennes. Kims vassa duo på Färjestad. Tremiljonershäst säljs på auktion ikväll. Derbyvinnaren vann direkt i ny regi. Straffspark för Kriterievinnare.
Detta och mer i söndagens ”Sju nyheter vid sju”.
Detta och mer i söndagens ”Sju nyheter vid sju”.
