
<p class="has-drop-cap">Rent historiskt har <strong>San Moteur</strong> varit oerhört bra när han varit borta under längre perioder, men till skillnad från tidigare har det varit på grund av olika problem. </p>



<p>– Den här gången har vi kunnat träna honom hela tiden och på det sättet känns det väldigt skönt. Allt har dessutom gått som på räls för San Moteur, säger Håkan Arvidsson.</p>



<p>Det var mycket funderingar fram och tillbaka innan den slutliga planen skissades upp för Prix d’Amérique efter att Björn Goops häst kvalat in som tvåa i Prix de Bretagne efter Hussard du Landret.</p>



<p>– Flera olika scenarion målade vi upp, men bestämde oss några dagar efter starten på Åby – Legolas Minne – att vänta till Prix d’Amérique eftersom San Moteur ska starta i Prix de France 14 dagar senare. Vi ville inte riskera att det skulle bli ett lopp för mycket.</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2023/07/sanmoteur42-617x333.jpg" alt="" class="wp-image-471349"/><figcaption class="wp-element-caption">Håkan Arvidsson, San Moteur och Jessica Jonsson. Foto Mathias Hedlund/Sulkysport</figcaption></figure>



<p class="has-drop-cap">San Moteur är en ren familjeangelägenhet. Håkans pappa Berndt Arvisson satt själv i sulkyn när mormors mor <strong>Tiba Lavec </strong>vann Breeders Crown för treåringar i Halmstad 1994. </p>



<p>Det är Ata Star L-dottern som lett fram till San Moteur och detta via ostartade mormor <strong>Kissy Suzuky</strong> (e. Tenor de Baune) och modern <strong>Aung San Suu Kyi</strong> (e. Ready Cash), 1.13,6am/174.300 kr.</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2025/01/tibalavecheat-617x333.jpg" alt="" class="wp-image-680042"/><figcaption class="wp-element-caption">Tiba Lavec med Berndt I Arvidsson. Foto Stefan Melander/Stalltz.se</figcaption></figure>



<p>Tiba Lavec sprang in 1.382.450 kronor och tog rekordet 1.14,5am, medan hennes dotter Kissy Suzuky aldrig kom till start. Hon kvalade på 1.25,5 över full distans som tvååring.</p>



<p>– Hon var fin till 1.30-tempo, men sen var hon inget fin länge. Helt enkelt var det för mycket franskt i henne, men det har vi fått igen nu istället. Att San Moteur har Ready Cash, Tenor de Baune och Tibur i stamtavlan är lite roligt. Men det var en liten tabbe från min sida att välja Tenor de Baune och det hade vi inte gjort om Mattias Lind varit med då.</p>



<p>Till Mattias Lind återkommer vi senare…</p>



<p>Även om Kissy Suzuky inte kom till start blev Tiba Lavec lyckosam i avelsboxen med i första hand miljonvinnande duon <strong>Psycho </strong>(e. From Above), 1.12,4am/1.829.017 kr, och <strong>You Talking to Me</strong> (e. Credit Winner), 1.11,7ak/1.771.556 kr.</p>



<p class="has-drop-cap">Modern <strong>Aung San Suu Kyi</strong> (e. Ready Cash) kom däremot ut på tävlingsbanan och vann tre av elva starter.</p>



<p>– Hon hade råstyrka, men tyvärr var hon alldeles för stimmig i huvudet och vi tog henne till avel. Jag har aldrig trott så mycket på en häst som henne i aveln. En otroligt fin häst och lite storlek för att vara en avkomma till<strong> Ready Cash</strong>. Jag tror hon mäter runt 165 centimeter i mankhöjd.</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2022/06/pannedemouteurokh14042stalltz-617x371.jpg" alt="" class="wp-image-311407"/><figcaption class="wp-element-caption">Panne de Moteur och Örjan Kihlström. Foto: stalltz.se</figcaption></figure>



<p>Då kanske det var konstigt att Håkan Arvidsson valde en oprovad hingst som <strong>Panne de Moteur</strong>…</p>



<p>– Jag har ju tyckt själv att jag varit skapligt duktig på stammar, men tog hjälp av Mattias Lind som jag haft häst i lag med och som är otroligt vass på att se på det mer matematiskt. Han ville att vi skulle gå till <strong>Raja Mirchi,</strong> men det satte jag stopp för eftersom Aung San Suu Kyi var ganska tung och då kom <strong>Credit Winner</strong> upp som förslag, men jag tyckte att det var lite för gammalt.</p>



<p>En kort tid efteråt ringde Mattias och gav förslaget Panne de Moteur.</p>



<p>– Han tyckte att vi skulle välja honom framför <strong>Muscle Hill </strong>och alla andra topphingstar och det förslaget köpte jag direkt eftersom vi skulle få både Credit Winner och <strong>American Winner</strong> och en återknytning på <strong>Valley Victory </strong>på modersidan. Panne de Moteur var en billig hingst och tror att jag betalade 25.000 eller 30.000 kronor.</p>



<blockquote class="wp-block-quote is-layout-flow wp-block-quote-is-layout-flow">
<p>Utan Mattias ingen San Moteur</p>
</blockquote>



<p>Mattias Lind har varit värdefull för Håkan Arvidsson när det gäller uppfödning och hitta rätt avelshingst till hans fölston. </p>



<p>– Utan Mattias Lind ingen San Moteur och så är det bara. Mattias har hjälpt oss under senare år med vilka hingstar vi ska betäcka våra ston med och det har blivit ett riktigt lyft sedan han kom in i bilden. Lite komiskt i sammanhanget är att Mattias Lind började ringa till mig nästan var 14:e dag när jag började köra San Moteur och han frågade hela tiden ”hur går det med din nästa stjärna?”</p>



<p>Aung San Suu Kyi har bara fått tre avkommor, varav två är i startbar ålder och den tredje föddes ifjol. En hingst efter Maharajah döpt till <strong>Mugshot</strong>.</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2025/01/florencebgm230416adamstromstalltz-617x395.jpg" alt="" class="wp-image-680053"/><figcaption class="wp-element-caption">Florence och Björn Goop. Foto: Adam Ström/stalltz.se</figcaption></figure>



<p>– Vi betäckte ytterligare en gång med Panne de Moteur och fick<strong> Florence</strong>. Hon började väldigt starkt, men gjorde sig illa i hagen och fick inte visa hur bra hon var.</p>



<p>Fem segrar på tolv starter, rekordet 1.13,0am och 358.000 kronor gav hennes korta karriär i utbyte.</p>



<p>– Ifjol betäcktes Florence första gången och hon är dräktig efter <strong>Calgary Games</strong>.</p>



<p>Däremot har Aung San Suu Kyi har bara två avkommor efter att San Moteur föddes 2017.</p>



<p>– Tyvärr har hon varit svår att få dräktig och hon har även kastat någon gång. I år var tanken att hon skulle betäckas med <strong>Tactical Landing</strong>, men eftersom det inte fungerade med honom tidigare valde vi hans son<strong> Fame and Glory</strong> och får en generationsväxling till. Ungefär på samma sätt som det blev när San Moteur kom till världen.</p>



<blockquote class="wp-block-quote is-layout-flow wp-block-quote-is-layout-flow">
<p>Tyckte namnet lät häftigt</p>
</blockquote>



<p>Och så var det här med namnen. Kissy Suzuky är namngiven efter en karaktär i James Bond-filmen ”You Only Live Twice.”</p>



<p>– Det var Anders Ström som kom med det förslaget och jag känner honom sedan vi var unga. Aung San Suu Kyi kom jag på själv och när jag hörde namnet tyckte jag att det lät häftigt. Sedan fick hon ju ta emot Nobels Fredspris, men jag tyckte också det var lite roligt eftersom det var krångligt att uttala, men landets referenter behövde ju inte bry sig eftersom hon aldrig kom till start.</p>



<p class="has-drop-cap">Tittar vi tillbaka riktigt långt i San Moteurs stamtavla hittar vi <strong>Margaret Parrish</strong>. Hon föddes 1908 och var en dotter till <strong>Vice Commodore</strong> och <strong>Lady Leyburn</strong>. Snabb på tävlingsbanan – tog rekordet 1.18,5 i time trial – och blev odödlig som avelssto. En av hennes första avkommor var <strong>Arion Guy </strong>(e. Guy Axworthy), 1.14,3*, som satte världsrekord för fyraåriga hingstar 1921 i Lexington.</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2025/01/margaretarion-617x481.jpg" alt="" class="wp-image-679874"/><figcaption class="wp-element-caption">Margaret Arion.</figcaption></figure>



<p>En annan berömd häst i hennes barnaskara var dottern <strong>Margaret Arion</strong> (e. Guy Axworthy) – född 1923 – med rekordet 1.21,1 i time trial. I avelsboxen blev hon en pyramidal succé. Hon var det första stoet att producera två Hambletonian-vinnare och tre segrare i Kentucky Futurity.</p>



<p>I avelsboxen levererade hon in i det sista och vid 25 års ålder 1933 blev hon mor till <strong>Margaret Castleton</strong> (e. Guy Castleton), 1.14,2*, på Walnut Hall Farm.</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2025/01/themarchioness-617x476.jpg" alt="" class="wp-image-679877"/><figcaption class="wp-element-caption">The Marchioness.</figcaption></figure>



<p><strong>The Marchioness</strong> (e. Peter Volo), 1.14,1<em>/</em>$55.721, vann både Hambletonian Stakes och Kentucky Futurity 1932. <strong>The Ambassador </strong>(e. Scotland), TT 1.15,8/$21.014, tog hem Hambletonian 1942. Vidare segrade <strong>Protector</strong> (e. Peter Volo), 1.14,1/$34.319, och <strong>Princess Peg</strong> (e. Volomite), 1.15,0*/$12.350, i Kentucky Futurity 1931 respektive 1934.</p>



<p>The Protector var aldrig anmäld till Hambletonian Stakes var bäst i sin årgång och enligt den tidens experter hade Peter Volo-sonen vunnit loppet med längder.</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2025/01/protector-617x461.jpg" alt="" class="wp-image-679879"/><figcaption class="wp-element-caption">Protector.</figcaption></figure>



<p>Margaret Arion dog 1946 på Walnut Hall Farm och hennes största bedrift leder till Valley Victory via dottern <strong>Princess Peg</strong>. Och så – med svenska ögon – förstås San Moteur!</p>



<p><strong>Princess Peg </strong>(e. Volomite) såldes på Walnut Hall Farms auktion som ettåring i november 1932 för 3.300 dollar och det året snittade stuteriet ettåringar 360 dollar och 67 cent och att inte priserna i stack iväg berodde mycket på efterdyningarna efter börskraschen några år tidigare på Wall Steet i New York.</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2025/01/princesspeg-617x426.jpg" alt="" class="wp-image-679878"/><figcaption class="wp-element-caption">Princess Peg.</figcaption></figure>



<p>Princess Peg ingick i Volomites första årgång och hon tränades av Fred Egan. Segern i Kentucky Futurity var den största, men hon gick också till skiljeheat i Hambletonian Stakes. Det blev dock galopp utvändigt ledaren på målrakan i ett lopp där hon ställdes mot stallkamraterna <strong>Lord Jim</strong> och <strong>Muscletone</strong>. Den senare gick vidare och vann Prix d’Amerique både som fyra- och sexåring, 1935 och 1937.</p>



<p class="has-drop-cap">Princess Peg blev mor till <strong>Lucy Abbey </strong>(e. Guy Abbey), vilken aldrig kom till start utan sattes i avelsboxen. När Lucy Abbey var 18 år när hon födde sin 15:e och sista avkomma och det blev <strong>Lou Sidney</strong> (e. Darnley). Inte heller hon hittade till tävlingsbanan utan gick till avel som fyraåring. Hennes femte avkomma <strong>Noble Action</strong> (e. Noble Victory) – född 1968 – står med 120 insprungna dollar i den amerikanska stamboken, men det är inte med sanningen överensstämmande.</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2025/01/lousidney-617x493.jpeg" alt="" class="wp-image-679776"/><figcaption class="wp-element-caption">Lou Sidney.</figcaption></figure>



<p>Till Sverige och Sören Nordin kom han som treåring och totalt blev det 20 vinster på 62 starter, rekordet 1.15,3ak och 318.505 kronor. Största segrarna togs i Hugo Åbergs Memorial, Oslo Grand Prix, Arvid Stjernswärds Minneslöpning, Gävle Stora Pris, N.J. Koster Memorial och Big Noon-Pokalen.</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2025/01/nobleactionnordinsoren-617x395.jpg" alt="" class="wp-image-680247"/><figcaption class="wp-element-caption">Noble Action och Sören Nordin. Foto: stalltz.se</figcaption></figure>



<p>Senare blev Lou Sidney mor till världsrekordhållaren <strong>Superlou</strong> (e. Super Bowl), 1.13,0/$278.465, vilken vann 32 lopp, varav flera penningstinna stakes och slutade dessutom tvåa i Hambletonian Oaks.</p>



<p>Nämnas ska också trion <strong>Special Notice,</strong> 1.14,0/$150.331, <strong>Pete Sidney</strong>, 1.16,8/$134.190, och heatvinnaren i Hambletonian Stakes <strong>Formal Notice</strong>, 1.13,6/$79.193 – samtliga med <strong>Kimberly Kid </strong>som far. Som kuriosa kan sägas att Special Notice vann lopp både i trav och passgång.</p>



<p class="has-drop-cap">1972 föddes <strong>Victorious Lou</strong> (e. Noble Victory), 1.14,0*/$48.836, och hon skolades in av Ned Bower på Ben White Raceway i Florida. Som tvååring vann hon Arden Downs, båda heaten i Review Futurity i Springfield med catchdrivern Glen Garnsey i sulkyn.</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2025/01/victoriouslounedbrower-617x772.jpg" alt="" class="wp-image-680027"/><figcaption class="wp-element-caption">Victorious Lou och Ned Brower.</figcaption></figure>



<p>Under treåringssäsongen blev det tuffare när hon mötte travare som<strong> Keystone Pioneer</strong>, <strong>Meadow Bright </strong>och <strong>Brilliance</strong>. Rekordet 1.14,0 sattes i time trial och det blev endast en vinst i ett vanligt lopp på 17 starter.</p>



<p>Hon lämnade tävlingsbanan med 48.836 dollar och kort efteråt gick hon till avel. Ägaren Bill Hayes sålde henne till Castleton Farm. Hennes tre första föl var efter <strong>Super Bowl </strong>och därefter ett sto efter <strong>Bonefish</strong> vid namn <strong>Valley Victoria</strong>.</p>



<p class="has-drop-cap">Valley Victoria köptes som ettåring av Bill Weaver för 135.000 dollar, men blev ingen succé på tävlingsbanan. Vinnarrekordet 1.15,0* och intjänade 6.719 dollar blev facit efter två säsonger. Hon kvalade en gång som fyraåring, men gick till avel samma år och betäcktes med <strong>Baltic Speed </strong>och resultat blev <strong>Valley Victory</strong>.</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2025/01/valleyvictoryochsteveelliot-617x484.jpg" alt="" class="wp-image-680043"/><figcaption class="wp-element-caption">Valley Victory och Steve Elliot.</figcaption></figure>



<p>När den ettårige hingsten Valley Victory bjöds ut på auktion hade Arlene Traub satt en limit på 30.000 dollar, men hästen gick upp i 60.000 dollar och Traub ändrade sig. Hästen gick i träning till Jan Johnsson och Continental Stable. Träningsrapporterna från Jan Johnson var positiva, men i slutet av januari som nybliven tvååring fick hon ett samtal från Jan Johnson.</p>



<p>– Din häst är på väg till University och Florida i Gainesville med tarmvred. Förvänta inte dig att du får se honom i livet igen. Normalt brukar inte hästar överleva den här typen operationer, var Jan Johnsons besked till Arlene Traub.</p>



<p class="has-drop-cap">Valley Victory lyckades överleva, bli en framgångsrik tävlingshäst och en ännu vassare avelshingst. Han ingick i samma årgång som <strong>Peace Corps</strong> och det året såldes Hamblentoian Stakes in som ”The Baltic Battle”, men Valley Victory kom inte till start och Peace Corps tävlade under pari.</p>



<p>Valley Victory var nära att dö efter ett snabbjobb inför Beacon Course – numera Stanley Dancer Memorial – och därmed hade han gjort sitt efter 14 starter, elva segrar, rekordet 1.11,8 och 485.307 dollar.</p>



<p>Vägen till San Moteur går inte via Valley Victorys mor Valley Victoria utan via Victory Lou’s vinstrikaste dotter <strong>Victorious Tail </strong>(e. Bonefish), 1.11,6*/$142.996, vilken tränades av Jan Johnson, Berndt Lindstedt och Håkan Walner. I USA hade hon vunnit 13 lopp och däribland Arden Downs, Zweig Memorial Filly, dubbla försök och final i Kentucky Sire Stakes, varit tvåa i såväl försök som final i Kentucky Futurity som Maple Leaf Trot.</p>



<p>Att Victorious Tail kom till Sverige var mycket av en tillfällighet genom Svenska Dagbladets travjournalist Peep Kask och Solvallas mest berömde referent Bo Rydgren.</p>



<figure class="wp-block-image alignright size-sulky-liten2"><img src="https://sulkysport.se/wp-content/uploads/2025/01/borydgrentz-350x359.jpg" alt="" class="wp-image-680045"/><figcaption class="wp-element-caption">Bo Rydgren. Foto Stefan Melander/Stalltz.se</figcaption></figure>



<p>– Peep Kask liftade alltid till Solvallas tävlingar med Berndt Lindstedt och med mig hem efter loppen. Peep hade sett Victorius Tail tävla i Lexington och imponerats och lite senare läste jag en artikel i Canadian Sportsman att hästens ägare Al Libfeld bestämt sig för att inte hålla några tävlingshästar längre. På den tiden var jag lite av bollplank till Björn Pettersson (Stall Pieder) och jag var väl inte heller helt oskyldig till att Björn köpte Peace Corps, säger Bo Rydgren, och fortsätter:</p>



<p>– Om jag inte minns helt fel var Victorius Tail väldigt lite stakad i USA som äldre och därför fanns det också möjlighet att köpa loss henne</p>



<p class="has-drop-cap">Sagt och gjort blev det affär och Stall Pieder handlade Victorious Tail. Hon gick i träning till Stig H Johansson och gjorde sin första start för honom i maj 1988 i München – fortfarande under Continental Farms flagg – och slutade oplacerad. Ytterligare en start blev det under Elitloppshelgen samma år, men där galopperade hon bort sig.</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2025/01/victorioustailtarzan-617x388.jpg" alt="" class="wp-image-680251"/><figcaption class="wp-element-caption">Victorious Tail och Berndt Lindstedt. Foto: stalltz.se</figcaption></figure>



<p>Senare flyttades hon till Axel Jacobsen. Hos honom blev det fyra starter och ett tredjepris som bäst. Vid en av starterna, på numera nerlagda Skovbo-banan, satt Olle Goop i sulkyn och det resulterade i ett femtepris.</p>



<p>Björn Pettersson hade inget större intresse för avel utan sålde Victorious Tail till Johan Dieden och då var hon dräktig med Sugarcane Hanover.</p>



<p>– Jag kom inte ihåg exakt vad Björn betalade för Victorious Tail, men jag tror att han fick tillbaka sina pengar, gissar Rydgren.</p>



<p>Johan Dieden lade upp 1.250.000 kronor för Victorious Tail och hennes första avkomma blev <strong>Victor Lavec</strong> (e. Sugarcane Hanover), 1.13,9ak/329.200 kr. Året efter föddes Tiba Lavec (e. Ata Star L.) och hon tränades upp av Svante Båth på Irland. </p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2017/02/dieden-617x411.jpg" alt="" class="wp-image-2218"/><figcaption class="wp-element-caption">Johan Dieden är uppfödare till Tiba Lavec.Foto Mia Törnberg</figcaption></figure>



<p>På våren som tvååring testades hon av Jimmy Takter, som Johan hade ett nära samarbete med, men Takter bedömde att stoet inte hade den potential som krävdes för att vara med och slåss i den amerikanska unghästcirkusen.</p>



<p class="has-drop-cap">Istället bjöds hon ut på Elitauktionen 1992 och Bertil Rogell skulle bevaka stoet för Diedens räkning och när hon kom upp i ringen hade Rogell annat för sig och då slog Håkan Arvidsson till. Stoet var inte helt obekant för honom och någon vecka innan auktionen såg han henne hos Bertil Rogell på Färjestad.</p>



<p>– När jag kollade upp stammen tände jag till på alla cylindrar, har Håkan Arvidsson berättat tidigare.</p>



<p>Hans far Berndt var inte heller speciellt svårövertalad och när klubban slogs på 90.000 kronor hade Håkan sista budet på Tiba Lavec.</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2025/01/skarmavbild20250121kl.09.54.38-617x786.jpg" alt="" class="wp-image-680280"/><figcaption class="wp-element-caption">Utdrag ur Rystadius auktionskatalog från Elithästauktionen 1993.</figcaption></figure>



<p>Ytterligare ett föl fick Victorius Tail för Johan Dieden – <strong>Kramer Bahama </strong>(e. Sugarcane Hanover), 1.15,2ak/59.200 kr – innan hon såldes tillbaka till andra sidan Atlanten och till sin tidigare ägare Al Libeld. </p>



<p>Al fick också skörda frukterna av Victorious Tail med avkommor som <strong>Chasing Tail </strong>(e. Donerail), 1.10,2/$800.056, <strong>Kick Tail </strong>(e. Sierra Kosmos), 1.10,2/$730.482, <strong>Day For Night </strong>(e. Donerial), 1.11,0/$616.907, och <strong>Comets Tail </strong>(e. Pine Chip), 1.10,6/$303.740, men det är en helt annan historia.</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2025/01/skarmavbild20250120kl.15.17.56-617x230.png" alt="" class="wp-image-680048"/><figcaption class="wp-element-caption">Stamtavla San Moteur. Källa: breedersbible.com</figcaption></figure>

Fokustema
Fokus: Prix d'Amérique
Läs senare
Tillfälligheternas travare
När alla pusselbitar faller på plats så kan man få en världsstjärna. På många olika sätt är det inte fel att kalla San Moteur för ”tillfälligheternas travare”.
På söndag tävlar han om segern i Prix d’Amérique.
Här är hela historien om den svenske stjärnan!
På söndag tävlar han om segern i Prix d’Amérique.
Här är hela historien om den svenske stjärnan!
