
<p class="has-drop-cap">1 Det vänder fort! <strong>När San Moteur</strong> (e. Panne de Moteur) gjorde debut på fransk mark i Prix du Bretagne låg fransk tipsmedia ytterst lågt kring hans möjligheter, men efter hans raketspurt i det loppet är tongångarna är helt annorlunda inför dagens Prix du Bourbonnais (€120.000).</p>



<p>Facktidningen Paris-Turf arrangerar ”20 tidningarnas tips” inför varje Quinté-omgång och där går det att konstatera att nio av 20 medier tippar San Moteur etta följt av <strong>Ampia Mede Sm</strong> som får tipsnicken av sju andra medier. De övriga fyra hästarna som tippas etta är <strong>Hokkaido Jiel</strong>,<strong> Izoard Vedaquias</strong>, <strong>Hooker Berry</strong> samt <strong>Horsy Dream</strong>, men den sistnämnde blev under lördagen struken från loppet.</p>



<p>Tomas Malmqvists Harper Hanovers lopp-vinnare <strong>Eric the Eel</strong> (e. Muscle Hill) tillmäts inte alls samma möjlighet utan rankas som bäst sjua av en tidning samt åtta av en annan.</p>



<p>Ifjolårets Prix du Bourbonnais var det <strong>Hooker Berry</strong>, <strong>Hussard du Landet </strong>och <strong>Etonnant</strong> som lade beslag på topplaceringarna tillika PDA-biljetterna och den trion finns även med i årets startfält.</p>



<p><a href="https://sulkysport.se/fokus/pda-jakt-i-ourasipraglad-dress/" target="_blank" rel="noreferrer noopener">Lär Sulkysports långa intervju med Håkan Arvidsson om San Moteur här!</a></p>



<h3 class="wp-block-heading">Startlista Prix du Bourbonnais</h3>



<p><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>



<p><strong>Namn – Körsven/Tränare</strong></p>



<ol class="wp-block-list">
<li><strong>Galileo Bello</strong> – Guillaume/Anne Francoise Donati Marc</li>



<li><strong>Evaluate </strong>– Gabriel Angel Pou Pou/Gabriel Angel Pou Pou</li>



<li><strong>Eric the Eel</strong> – Franck Ouvrie/Tomas Malmqvist</li>



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



<li><strong>Hokkaido Jiel*</strong> – David Thomain/Jean-Luc Dersoir</li>



<li><strong>Horsy Dream*</strong> – Eric Raffin/Pierre Belloche</li>



<li><strong>Izoard Vedaquais*</strong> – Benjamin Rochard/Philippe Allaire</li>



<li><strong>Hussard du Landret*</strong> – Yoann Lebourgeois/Benoït Robin</li>



<li><strong>Elvis du Vallon*</strong> – Mathieu Mottier/Charles Cuiller</li>



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



<li><strong>Gu d’Heripre* </strong>– Francois Lagadeuc/Fabrice Souloy</li>



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



<li><strong>Diable de Vauvert* </strong>– Tony Le Beller/Bertrand Le Beller</li>



<li><strong>Ampia Mede Sm*</strong> – Franck Nivard/Fabrice Souloy</li>



<li><strong>Hooker Berry*</strong> – Nicolas Bazire/Jean-Michel Bazire</li>



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



<li><strong>Hohneck</strong> – Gabriele Gelormini/Philippe Allaire</li>



<li><strong>Etonnant</strong> – Anthony Barrier/Richard Westerink</li>
</ol>



<p><strong>Fotnot: *</strong>startade i Prix de Bretagne.</p>



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



<p class="has-drop-cap">2 Nog för att det står Prix d’Amerique-platser på spel i Prix du Bourbonnais, men faktum är att det avgörs ett högre doterat lopp på <strong>Vincennes</strong> (första start kl. 13.23) under eftermiddagen.</p>



<p>Grupp I-klassade Prix de l’Etoile (€200.000) är numera ett internationellt Grupp I-lopp och fem av de 16 treåringarna som gör upp om segerchecken på 90.000 euro är födda i andra länder än Frankrike.</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2023/09/fiftyfourronjagingsjoadam-617x347.jpeg" alt="" class="wp-image-495515"/><figcaption class="wp-element-caption">Fiftyfour tillsammans med sin skötare Ronja Gingsjö efter segern i korta E3-finalen. Foto Adam Ström/StallTZ.se</figcaption></figure>



<p>Bland dem finns Tomas Malmqvists Kriterietvåa <strong>Fiftyfour</strong> (e. Fourth Dimension) som nu gör debut på kolstybben och det sker från ett andraspår bakom bilen i lag med Björn Goop.</p>



<p>Malmqvist startar även den franskfödda duon <strong>Kapitano de Source</strong> (e. Ready Cash) och <strong>Kobayashi </strong>(e. Face Time Bourbon) i detta lopp vilka körs av Gabriele Gelormini samt Franck Nivard.</p>



<p>Tre svenskfödda hästar kommer till start i femåringsloppet Prix de Grenoble (€60.000). Christoffer Erikssons <strong>Django Silver</strong> (e. Django Riff), Thierry Duvaldestins <strong>Mister Invictus</strong> (e. Ready Cash) och Jörgen Westholms <strong>Beat Generation</strong> (e. Bird Parker) tillhör deltagarskaran i detta sadellopp där det tävlas om 27.000 euro i segerpremie.</p>



<p>Svenskhopp finns även i Prix de Luxe (€46.000) genom Tomas Malmqvists <strong>Jasmin du Vallon</strong> (e. Royal Dream) och så tävlar Marie Norbergs <strong>Istania de Viette</strong> (e. Carat Willams) i Prix de Bussieres (€46.000).</p>



<p><a href="https://sulkysport.se/trav-och-galopp/paris-vincennes-2023-12-10/" data-type="link" data-id="https://sulkysport.se/trav-och-galopp/paris-vincennes-2023-12-10/" target="_blank" rel="noreferrer noopener">Här kan du ta del av söndagens startlistor till tävlingarna på Vincennes.</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 – Prispengar</strong></p>



<ul class="wp-block-list">
<li><strong>Jazzy Perrine</strong> (e. Django Riff) – Tomas Malmqvist – trea – 16.800 euro</li>



<li><strong>Kagan</strong> (e. Scarlet Knight) – Robert Bergh – trea – 11.200 euro</li>



<li><strong>Coquaholy</strong> (e. Orlando Vici) – Tomas Malmqvist – fyra – 9.600 euro</li>



<li><strong>Hurricane River </strong>(e. Up and Quick) – Christoffer Eriksson – trea – 8.260 euro</li>



<li><strong>Global Dancer</strong> (e. Carat Williams) – Fredrik Wallin – femma – 6.000 euro</li>



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



<li><strong>Aurelia Express</strong> (e. Readly Express) – Timo Nurmos – sexa – 2.400 euro</li>



<li><strong>Harpy </strong>(e. Bar Hopping) – Robert Bergh – sjua – 1.200 euro</li>



<li><strong>Bonneville W.I.</strong> (e. S.J.’s Caviar) – Timo Nurmos – disk. – 0 euro</li>



<li><strong>Dubai Kronos</strong> (e. Ready Cash) – Sébastien Guarato – opl. – 0 euro</li>



<li><strong>Global Warrior </strong>(e. S.J.’s Caviar) – David Cinier – opl. – 0 euro</li>



<li><strong>Indy Rock</strong> (e. Readly Express) – Daniel Redén – disk. – 0 euro</li>



<li><strong>M.T. Oscar</strong> (e. Yarrah Boko) – Tomas Malmqvist – opl. – 0 euro</li>



<li><strong>Rocky Tilly</strong> (e. Ready Cash) – Jörgen Westholm – opl. – 0 euro</li>
</ul>



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



<p class="has-drop-cap">3Sju försök en gång i månaden från april till oktober ledde fram till Månadsloppetsm final på <strong>Mantorptravet</strong> (först start 13.45). Av de sju försöksvinnarna finns tre med i finalen i eftermiddag när östgötabanan är ensam på plan på svensk travmark.<br>Det handlar om trion <strong>Nat King Cole</strong> (e. Muscle Hill), <strong>Winner Brodde</strong> (e. Raja Mirchi) och <strong>Quantity of Time</strong> (e. Victor Gio). Tio hästar gör upp om prischecken på 100.000 kronor, där försöksvinnarna bland annat får sällskap av miljonären <strong>Zenato</strong> (e. Gift Kronos) i en spårtrappa.</p>



<p>Mantorptravet slog upp portarna 1965. Det året fanns en enda proffstränare vid banan: <strong>Sture Lindström</strong>. I eftermiddag hedras Sture med sitt eget lopp på banan.<br>Sture Lindström var född och uppväxt i Skellefteå, där han inledde sin bana i travsporten. I banprogrammet till eftermiddagens tävlingar berättas att hästägaren Åke Bengtsson i Linköping lockade Sture söderut när Mantorptravet skulle öppna och det blev drygt 40 år i Östergötland för Lindström. Som kusk plockade han sitt första banchampionat i Mantorp 1968 och totalt blev det nio titlar på hemmabanan, det sista togs 1981. Fler än någon annan på banan.</p>



<p>Aspirant Nibs, Dictator Nibs, Parant Nibs, Red Nibs, Seabreeze, Ideal Way, Sweet Way och inkörsporten Hopp är hästar som förknippas med Sture Lindström.<br><em>”I Stures stall var det ordning och reda. Välorganiserat med fasta rutiner så långt det nu är möjligt i ett travstall”, </em>beskrivs Stures sätt att vara i Mantorps banprogram.<br>Tio hästar gör upp om förstapriset 50.000 kronor i årets upplaga av Sture Lindströms lopp.</p>



<p><a href="https://sulkysport.se/wp-content/uploads/2023/12/231210.pdf" target="_blank" rel="noreferrer noopener">Här är startlistorna till söndagens tävlingar.</a></p>



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



<p class="has-drop-cap">4 Fyraåriga stoet <strong>Proximity</strong> (e. Propulsion-Volontary Simplcty), 1.13,5ak*/278.000 kr, toppade gårdagens Travera-auktion och Rutqvist i Boden AB betalade 350.000 kronor för den tidigare Daniel Redén-tränade travaren.</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2023/12/proximitympdm231018adamstromstalltz-617x374.jpg" alt="" class="wp-image-532330"/><figcaption class="wp-element-caption">Proximity och Martin P Djuse. Foto: Adam Ström/stalltz.se</figcaption></figure>



<p>Fyra segrar på 14 starter har det blivit för Proximity, varav två tagits på huvudstadsbanan. En gång tidigare har Proximity klivit in i en ring och som ettåring ropades hon tillbaka för 306.000 kronor på Elitauktionen.</p>



<p><a href="https://www.travera.nu/auktionsresultat/" data-type="link" data-id="https://www.travera.nu/auktionsresultat/" target="_blank" rel="noreferrer noopener">Här hittar ni samtliga resultat från Travera-auktionen.</a></p>



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



<p class="has-drop-cap">5 Tidigare i år har det rapporterats att <strong>French Wine</strong> – världens snabbaste treåring 2023 – skulle uppstallas som avelshingst på Winterford Farm i Ohio nästa år, men nu har det visat sig att sonen till Bar Hopping och Creamy Mimi är steril, skriver Harnesslink.</p>



<figure class="wp-block-image alignright size-sulky-liten2"><img src="https://sulkysport.se/wp-content/uploads/2022/07/frenchwine2172022gracezimmers-350x233.jpg" alt="" class="wp-image-331020"/><figcaption class="wp-element-caption">French WIne och Andy Miller vid en tidigare seger. Foto: Grace Zimmers</figcaption></figure>



<p>Nu lutar det mesta åt att French Wine, 1.08.4*/$1.014.905, återvänder till tävlingsbanan 2024. Hittills har han startat 28 gånger (8-7-7) och sin största seger tog han som tvååring i Kentucky Sire Stakes ($400.000), medan det blivit finaltriumf i Pennsylvania Sire Stakes ($252.000) i år. Nämnas kan också andrapriset i Kentucky Futurity och en tredjeplats i Breeders Crown.</p>



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



<p class="has-drop-cap">6 Det är inte bara på Vincennes som bjuder på stortrav idag. Tre Grupp I-lopp avhålls på Agnano-banan i Neapel och allra störst intresse drar tvååringarna till sig i Gran Premio Allevamento Masaf (€180.400), som har en avdelning för hingstar respektive ston.</p>



<p>Gran Premio Royal Mares (€100.100) för fyraåriga och äldre ston har lockat åtta hästar, varav fem selas ut från Alessandro Gocciadoros stall.</p>



<p><strong>Gran Premio Allevamento Masaf Femmini</strong> (€180.400)<br>Tvååriga ston.<br><em>2.100 meter, autostart.</em></p>



<p><strong>Namn (far) – Körsven</strong></p>



<ol class="wp-block-list">
<li><strong>Funny Gio </strong>(e. Face Time Bourbon) – Alessandro Gocciadoro</li>



<li><strong>Fenice del Ronco </strong>(e. Maharajah) – Santo Mollo</li>



<li><strong>Fantastica Doda</strong> (e. Maharajah) – Vinzenco P Dell’Annunziata</li>



<li><strong>Francy Caf</strong> (e. Nad al Sheba) – Pietro Gubellini</li>



<li><strong>Follow Me Love</strong> (e. Owen’s Club) – Lorenzo Baldi</li>



<li><strong>Favola Cap</strong> (e. Oasis Bi) – Gaetano di Nardo</li>



<li><strong>Federica Jet </strong>(e. Maharajah) – Antonio Greppi</li>



<li><strong>Flicka </strong>(e. Pascia’ Lest) – Antonio di Nardo</li>



<li><strong>Florence d’Or </strong>(e. Nesta Effe) – Michele di Francia</li>



<li><strong>Fisic du Rol</strong> (e. Maharajah) – Roberto Vecchione</li>



<li><strong>Favola del Ronco</strong> (e. Maestrale Spin) – Ferdinando Minopoli</li>



<li><strong>Freccia dei Venti </strong>(e. Donato Hanover) – Giuseppe Jr. Lombardo</li>



<li><strong>Favola Ek</strong> (e. Every Time Bourbon) – Andrea Guzzinati</li>



<li><strong>Framcesina Ors</strong> (e. Maestrale Spin) – Mario Minipoli Jr.</li>
</ol>



<p><strong>Gran Premio Allevamento Masaf Maschi</strong> (€180.400)<br>Tvååriga hingstar.<br><em>2.100 meter, autostart.</em></p>



<p><strong>Namn (far) – Körsven</strong></p>



<ol class="wp-block-list">
<li><strong>Francesco Grif </strong>(e. Maharajah) – Vincenzo Luongo</li>



<li><strong>Felipe Roc </strong>(e. Filipp Roc) – Santo Mollo</li>



<li><strong>Fellow Wise As</strong> (e. Maharajah) – Alessandro Gocciadoro</li>



<li><strong>Floy di Girifalco</strong> (e. Donato Hanover) – Gennaro Riccio</li>



<li><strong>Frankie LJ</strong> (e. Readly Express) – Antonio di Nardo</li>



<li><strong>Flamenco Zack </strong>(e. Tuonobleu Rex) – Gaetano di Nardo</li>



<li><strong>Folletocar</strong> (e. Adrian Chip) – Andrea Guzzinati</li>



<li><strong>Fil Ek</strong> (e. Ringostarr Treb) – Pietro Gubellini</li>



<li><strong>Frodo Baba </strong>(e. Wishing Stone) – Marcello Vecchione</li>



<li><strong>Far West Bi </strong>(e. Muscle Hill) – Antonio Simiolo</li>



<li><strong>Fandango Ga</strong>r (e. Varenne) – Roberto Vecchione</li>



<li><strong>Fabio Bi </strong>(e. Manofmanymissions) – Maurizio Biasuzzi</li>



<li><strong>Fidelis Dance</strong> (e. Robert Bi) – Simone Mollo</li>



<li><strong>Fascino Luis</strong> (e. Napoleon Bar) – Crescenzo Malone</li>



<li><strong>Fato d’Amore</strong> (e. Mago d’Amore) – Antonio Greppi</li>
</ol>



<p><strong>Gran Premio Royal Mares</strong> (€100.100)<br><em>1.600 meter, autostart.</em></p>



<p><strong>Namn – Körsven</strong></p>



<ol class="wp-block-list">
<li><strong>Vesna</strong> – Rene’ Legati</li>



<li><strong>Blackflash Bar </strong>– Santo Mollo</li>



<li><strong>Bonneville Gifont</strong> – Antonio Simioli</li>



<li><strong>Clarissa </strong>– Alessandro Gocciadoro</li>



<li><strong>Dea Grif </strong>– Andrea Guzzinati</li>



<li><strong>Zeudi Amg</strong> – Federico Esposito</li>



<li><strong>Daughter As</strong> – Pietro Gubellini</li>



<li><strong>Celeste Breed</strong> – Mario Minopoli Jr.</li>
</ol>



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



<p class="has-drop-cap">7 ATG har nyligen sjösatt möjligheten att köpa tillsammans-andelar även på V4 och idag är det dags för oss på Sulkysport att kliva in i leken.</p>



<p>Premiärspelet läggs till dagens högklassiga tävlingar på Vincennes där det är stora svenskintressen med <strong>San Moteur</strong> samt <strong>Fiftyfour</strong> som deltagare och båda hästarna tävlar inom just V4-spelet.</p>



<p>Förra gången det var B-lopp på Vincennes omsatte V4-spelet 681.095 kronor och gav 93.769 kronor i utdelning trots att en av de fyra favoriterna höll för trycket.</p>



<p>Vill du spela V4 till Vincennes tillsammans med Sulkysport så följer du nedanstående länk:</p>



<p><a href="https://www.atg.se/andelskungen/spel/260853_V4_2023-12-10_63_4" data-type="link" data-id="https://www.atg.se/andelskungen/spel/260853_V4_2023-12-10_63_4" target="_blank" rel="noreferrer noopener">Sulkysport V4 Vincennes – 8 andelar á 99 kr/styck</a></p>
